Friday, December 8, 2017

Solarwinds and MIMIC Simulator

If you need to develop and test customizations, or train staff on the
Solarwinds management application, then you can create a facsimile
of your production network in MIMIC Simulator and reproduce interesting
scenarios.

For example, here we show a simulated network being managed by Solarwinds.


Friday, November 17, 2017

Long-term testing with MIMIC Simulator

What do our test systems do over the weekend? They run longer-term tests
that we cannot run overnight.

For example, they run one MIMIC MQTT Simulator test that continuously in
a loop starts 1000 sensors, publishes messages for a while, then stops
them, as might happen in a real-world scenario.

The code is as simple as this:

% while ( 1 )
    ./mimicsh --nogui --script mqtt-start-many.mtcl --args "1 1000 1000"
    sleep 10
    ./mimicsh --nogui --script mqtt-stop-many.mtcl --args "1 1000 1000"
end

With this simple 5-line test we found that a third-party MQTT broker
was failing after a while. Apparently it was not configured to handle the
"TCP SYN flood" that the OS detected.

Chalk it up to another configurable on brokers that we learned the
hard way.

 If your MQTT broker does not have the configurables for SYN flooding
in their documentation, then you will encounter this problem in your
deployment when all those sensor connections start flapping.

This is but one of the many tests that you can perform with MIMIC MQTT
Simulator on your MQTT broker before IoT deployment to avoid costly
problems in the real world.


Thursday, November 9, 2017

Online MQTT Lab for your access

We have just released a SaaS lab with hundreds/thousands
of simulated MQTT sensors to prototype/test your IoT solution at

http://mqttlab.iotsim.io

You can test your applications by connecting to the lab at any time.

Check out the 3 minute video at

https://www.youtube.com/watch?v=cttbEh16MOI&hd=1


Monday, October 2, 2017

MIMIC MQTT Simulator integrates with Google IoT Core

While integrating simulated Bosch sensors in MIMIC MQTT Simulator
with Google IoT Core we implemented JSON Web Tokens (JWT) for the
MQTT Password, as standardized in RFC 7519 .

This allows for any number of devices publishing MQTT telemetry
with arbitrary authentication parameters to Google IoT Core or
any other IoT platform that requires JWT.

This is in addition to previous support for OAuth 2.0 .

The screenshot below shows 2 pulled subscriptions with unique
telemetry:


Monday, September 18, 2017

LWM2M-MQTT and MIMIC MQTT Simulator

Are you implementing LWM2M-MQTT in your environment?

MIMIC MQTT Simulator supports arbitrary payloads for MQTT messages
for a large number of simulated MQTT-enabled devices.

You can use it to quickly prototype your LWM2M-MQTT implementation.
In particular, you can test scalability of your LWM2M server over the MQTT
transport.

Thursday, September 14, 2017

How to right-size your IoT platform

You have run extensive tests on your IoT platform candidates, have gotten
QOS / performance guarantees from the vendor, and have selected the most
promising choice.  You may have even put money down.

Now that you are ready to deploy your IoT platform, these are the problems
you will need to solve:
  1. initial configuration

    Likely the IoT platform will need to be tuned to your individual
    requirements in the production environment, which is likely much
    different than your test environment. You may have tested in-house,
    and are deploying on the cloud, or vice versa.

    Configuration does not only involve the middleware software components,
    but the OS itself, as we had learned in this post.

    For example, it took us multiple tries until we could scale ActiveMQ
    to 20,000 simultaneous client connections. Out of the box, on a 8-CPU
    system, we could only scale to about 800 sessions. Then we applied ARP
    cache- and thread-tuning, and got to 7,000 sessions.  Only on the third
    try did we get to 20,000 sesssions.

    You will face this with any IoT platform. With MIMIC MQTT Simulator this
    exercise took an hour including research on this unknown software.
    How long will / would it take you?

  2. end-to-end tuning

    The process above just gets us part-way to the ultimate requirements.
    There are many variables that impact long-term run-time performance
    in your production environment:

    a) connect rate:

    at what rate do clients connect to the broker. For example, your devices
    may all simultaneously connect after a brownout, or there may be a
    steady trickle of sensors connecting and disconnecting during the day.
    Every scenario is different.

    b) publish rate:

    how often do clients publish telemetry? How large and what size
    distribution do the messages have? What QOS and encryption
    parameters are being used? The scenario of 1 message every minute
    with 100 bytes per sensor is quite different from a camera publishing
    hi-res images at 10 / second.

    c) consumption rate:

    how many applications are consuming messages? Since the broker is
    essentially a layer 4 switch, the fanout determines switching
    performance. Wildcard topic subscriptions challenge topic matching
    algorithms. Are your consumers running with enough power to not bog
    the broker down?

    MIMIC MQTT Simulator is highly customizable allowing you to vary all
    these variables to run many end-to-end scenarios to ensure adequate performance.

  3. devops

    You have your production system running, but how do you test that it
    scales up and down with varying performance levels? How do you test
    changes to your applications while it is running?

    With MIMIC you can run synthetic loads even on your production system
    to verify operational adjustments. Your broker cluster should absorb the
    extra load, and contract when the load is gone. By generating custom
    payloads you can test new features and fixes to your consumer application.

Tuesday, July 25, 2017

MIMIC interoperates with Cumulocity IoT Platform

We used the Cumulocity API detailed here to define 100 simulated sensors
with MIMIC MQTT Simulator as shown in this screenshot.





You can use MIMIC to quickly create any set of measurements, events
and alarms for a large number of IoT devices to test your real-time
application on Cumulocity.

Friday, July 14, 2017

NNMi discovers 2000 VOIP phones in simulated CUCM

HP's NNMi discovered the 2000 simulated phones in MIMIC Web Simulator
which was setup as a Cisco Unified Communications Manager (CUCM)
server.

Using MIMIC you can setup arbitrarily large environments of networking and
telephony devices to test, demo, POC and training on your application of
choice.


Tuesday, July 11, 2017

MIMIC Redfish Simulator to simulate large server farm

The DMTF Redfish Mockup may be adequate to simulate a small number
of servers to be managed with the Redfish API but now you can use
MIMIC Redfish Simulator to simulate Redfish on a large scale.

You can record one real server (or the Mockup), and simulate hundreds if
not thousands of servers to be managed by your Redfish manager application.

This is what  redfish-client saw when pointed at a simulated server:

(redfish) bash-4.3$ redfish-client system getinfo
Gathering data from manager, please wait...

Redfish API version :  1.02
Root Service

Systems information :
=====================

System id 437XR1138R2:
UUID : 38947555-7742-3448-3784-823347823834
Type : Physical
Manufacturer : Contoso
Model : 3500RX
SKU : 8675309
Serial : 437XR1138R2
Hostname : web483
Bios version : P79 v1.33 (02/28/2015)
CPU number : 2
CPU model : Multi-Core Intel(R) Xeon(R) processor 7xxx Series
CPU details :
    Processor id CPU1 :
    Speed : 3700
    Cores : 8
    Threads : 16
    
    Processor id CPU2 :
    Speed : Not available
    Cores : Not available
    Threads : Not available
    
Available memory : 96 GB
Status : State : OK / Health : OK
Power : On
Description : Web Front End node
Chassis : 1U
Managers : BMC
IndicatorLED : Off

Ethernet Interface :
    Ethernet Interface id 12446A3B0411 :
    Ethernet Interface
    FQDN : web483.contoso.com
    Mac address : 12:44:6A:3B:04:11
    Address ipv4 : 192.168.0.10
    Address ipv6 : fe80::1ec1:deff:fe6f:1e24
    Ethernet Interface id 12446A3B8890 :
    Ethernet Interface
    FQDN : backup-web483.contoso.com
    Mac address : AA:BB:CC:DD:EE:00
    Address ipv4 : 192.168.0.11
    Address ipv6 : fe80::1ec1:deff:fe6f:1e33
Looking for potential OEM information :
    This system has no supplemental OEM information


Simple Storage :
    Simple Storage id 1 :
    Simple Storage Controller
    Status : State : OK / Health : OK
    Device id 1 : SATA Bay 1  Contoso  3000GT8
    Device id 2 : SATA Bay 2  Contoso  3000GT7
    Device id 3 : SATA Bay 3    
    Device id 4 : SATA Bay 4    
Looking for potential OEM information :
    This system has no supplemental OEM information
--------------------------------------------------------------------------------

 and Redfishtool


% redfishtool -v --Secure=Never -r 10.0.0.1:80 root
#
#  Service Root:
{
    "@odata.type": "#ServiceRoot.v1_0_2.ServiceRoot",
    "Id": "RootService",
    "Name": "Root Service",
    "RedfishVersion": "1.0.2",
    "UUID": "85775665-c110-4b85-8989-e6162170b3ec",
    "Systems": {
        "@odata.id": "/redfish/v1/Systems"
    },
    "Chassis": {
        "@odata.id": "/redfish/v1/Chassis"
    },
    "Managers": {
        "@odata.id": "/redfish/v1/Managers"
    },
    "Tasks": {
 "@odata.id": "/redfish/v1/TaskService"
    },
    "SessionService": {
        "@odata.id": "/redfish/v1/SessionService"
    },
    "AccountService": {
        "@odata.id": "/redfish/v1/AccountService"
    },
    "EventService": {
        "@odata.id": "/redfish/v1/EventService"
    },
    "Links": {
 "Sessions": {
        "Sessions": {
            "@odata.id": "/redfish/v1/SessionService/Sessions"
        }
    },
    "@odata.context": "/redfish/v1/$metadata#ServiceRoot.ServiceRoot",
    "@odata.id": "/redfish/v1/",
    "@Redfish.Copyright": "Copyright 2014-2016 Distributed Management Task Force, Inc. (DMTF). For
the full DMTF copyright policy, see http://www.dmtf.org/about/policies/copyright."
}

Friday, July 7, 2017

MIMIC MQTT Simulator and CloudMQTT

We have added CloudMQTT to the list of public brokers that
MIMIC MQTT Simulator interoperates with little effort. This
screenshot shows 10 simulated sensors publishing unique JSON
message to a Mosquitto subscriber client.


Wednesday, May 31, 2017

British Airways loses business due to IT failure

In light of the British Airways IT disaster, we can illustrate the failure
of updating your IT system. Not only are revenues affected from a disruption
of operations, the stock price drops are proportional to the loss of trust in
your brand.

When it happens to you, how much will it cost you?

Mission-critical IT systems require testing your power failure cut-over and
other disastrous scenarios in advance. The IT staff needs to be familiar with
the network topologies and configurations so they are prepared for any such
conditions. This is where SNMP simulation is designed to reproduce disaster
scenarios to exercise your network management environment custom policies.

MIMIC Simulator is designed for disaster preparedness. MIMIC's device
recording and simulation capabilities help to create a replica of the production
network. This virtual lab can then be used to practice disaster scenarios and
recovery procedures without affecting the production network. With MIMIC, users
can easily remove a part of the network, shutdown major routers, simulate cut
cables, increase/decrease the traffic or generate trap storms. In this way, they
can experience how their management applications react to such conditions and
practice how to respond. The participants can gain real-world experience in
disaster response.

Are you completely prepared for the disasters? If not, take a look at MIMIC
Simulator.

Monday, May 8, 2017

Simulated VOIP NetFlow flows visualized with Kibana

When you have many branch offices with a VOIP telephone system, such
as any brick-and-mortar retailer, bank, or multi-national company,
you will have a monitoring system, likely based on NetFlow, to assure
smooth operations.

This system likely will require a lot of customization to fit into your
IT system. Thus, you will require development, testing and training of
these customizations.

This use-case documents the use of an ELK-based flow-monitoring solution
to monitor VOIP traffic. Instead of affecting the production network, a
simulator in a lab can recreate your network without impacting operations.

Kibana is visualizing simulated VOIP traffic between many phones and
a PBX through CUCM as is common in banks, retailers, brokers or any
brick-and-mortar branch office where there are a lot of phones. Intensity
of traffic can be customized at will to test detection of usage patterns
and security risks.

MIMIC NetFlow Simulator is generating realistic VOIP flows from many
branch-office phones to some external "outside" phone numbers. By
tailoring the flows to your needs, you can verify that your monitoring
system is reacting as expected.

For example, you can have many phones with expected usage, and a small
set of high-traffic phones, and see if they are detected.







Wednesday, March 15, 2017

MIMIC NetFlow Simulator drives ELK flow analyzer

Now you too can customize your ELK-based flow analysis by running through
many hard-to-reproduce scenarios with MIMIC NetFlow Simulator.

In the attached screenshot, we created a spike in an otherwise normal traffic
pattern on-demand on a simulated device in MIMIC, to see how the analyzer
treated it.

Kibana shows regular traffic except for the periods where we artificially
created traffic spikes. Any of the dimensions in the traffic matrix can be
manipulated at will.



Friday, March 10, 2017

Simulated sensors publishing to mqtt-spy

We are simulating 100 sensors with MIMIC MQTT Simulator publishing JSON
payloads through mqtt.ximxim.com to mqtt-spy .


Thursday, February 23, 2017

Vehicle fleet simulation with MIMIC MQTT Simulator

Simulated vehicles are publishing GPS coordinates via MQTT in real-time to
the Losant IoT platform, and the dashboard is tracking their movements
in real-time.

This 2-minute video was setup in a couple of hours. Each vehicle simulation
is independent from the others, moves along its own route, at its own speed.

With MIMIC MQTT Simulator you can create large-scale IoT environments
with upwards of 100,000 static and/or moving sensors/vehicles to test your
IoT application.


Tuesday, February 21, 2017

Publically accessible simulated SNMP agent for Cisco 7513

We have a simulated Cisco 7513 device available for you to test your
SNMPv1, v2c or v3 application.

You can access it using the address snmp.live.gambitcommunications.com .
Feel free to point your application to it.

Here are some examples on how to access it:


% snmpwalk -v 2c -c public snmp.live.gambitcommunications.com system
SNMPv2-MIB::sysDescr.0 = STRING: Cisco Internetwork Operating System Software ..IOS (tm) RSP Software (RSP-JSV56I-M), Version 12.1(7), RELEASE SOFTWARE (fc1)..Copyright (c) 1986-2001 by cisco Systems, Inc...Compiled Fri 23-Feb-01 05:14 by kellythw
SNMPv2-MIB::sysObjectID.0 = OID: SNMPv2-SMI::enterprises.9.1.46
DISMAN-EVENT-MIB::sysUpTimeInstance = Timeticks: (3651511261) 422 days, 15:05:12.61
SNMPv2-MIB::sysContact.0 = STRING: support@gambitcomm.com
SNMPv2-MIB::sysName.0 = STRING: cisco-7513
SNMPv2-MIB::sysLocation.0 = STRING:
SNMPv2-MIB::sysServices.0 = INTEGER: 78
SNMPv2-MIB::sysORLastChange.0 = Timeticks: (0) 0:00:00.00

It implements the following SNMPv3 authentication/privacy parameters:
% snmpget -v3 -uuser1 -lnoAuthNoPriv snmp.live.gambitcommunications.com sysDescr.0
% snmpget -v3 -uuser2 -lauthNoPriv -aMD5 -A1234567890abcdef snmp.live.gambitcommunications.com sysDescr.0
% snmpget -v3 -uuser3 -lauthNoPriv -aSHA -A1234567890abcdef snmp.live.gambitcommunications.com sysDescr.0
% snmpget -v3 -uuser4 -lauthPriv -aMD5 -A1234567890abcdef -xDES -X 1234567890abcdef snmp.live.gambitcommunications.com sysDescr.0
% snmpget -v3 -uuser5 -lauthPriv -aSHA -A1234567890abcdef -xDES -X 1234567890abcdef snmp.live.gambitcommunications.com sysDescr.0
% snmpget -v3 -uuser6 -lauthPriv -aMD5 -A1234567890abcdef -xAES -X 1234567890abcdef snmp.live.gambitcommunications.com sysDescr.0
% snmpget -v3 -uuser7 -lauthPriv -aSHA -A1234567890abcdef -xAES -X 1234567890abcdef snmp.live.gambitcommunications.com sysDescr.0
% snmpget -v3 -ncontext11 -uuser11 -lnoAuthNoPriv snmp.live.gambitcommunications.com sysDescr.0
% snmpget -v3 -ncontext12 -uuser12 -lauthNoPriv -aMD5 -A1234567890abcdef snmp.live.gambitcommunications.com sysDescr.0
% snmpget -v3 -ncontext13 -uuser13 -lauthNoPriv -aSHA -A1234567890abcdef snmp.live.gambitcommunications.com  sysDescr.0
% snmpget -v3 -ncontext14 -uuser14 -lauthPriv -aMD5 -A1234567890abcdef -xDES -X 1234567890abcdef snmp.live.gambitcommunications.com sysDescr.0
% snmpget -v3 -ncontext15 -uuser15 -lauthPriv -aSHA -A1234567890abcdef -xDES -X 1234567890abcdef snmp.live.gambitcommunications.com sysDescr.0

Monday, January 23, 2017

How is a commercial SNMP simulator different from a free SNMP simulator?

In a previous post we have detailed the tradeoffs of building your own SNMP
simulator. In the end it comes down to return on investment (ROI): do you
want to spend time and effort (thus $$$) on something that is not your core
competency?

In this post we lay out the technical reasons to choose a commercial
solution like MIMIC SNMP Simulator   over a free, open-source version if you
want to simulate more than a the simplest scenario on more than a small
scale (a few dozen devices):

1. performance: in order to perform adequately, a simulation has to satisfy
the equation

 power (simulator) >= power (management application)

that is, the simulator has to be at least as powerful as the management
side. For example, if the management app runs on a 32 CPU server (or
multiple servers) and the simulator on only a single CPU server, then
your response time is guaranteed to suffer under high load.

But, even if you have a powerful server on the simulator side, open
source solutions will likely not use that power. They are single-threaded,
running all your simulated devices in a single thread, regardless of the
power of your server. A good commercial solution will use all the CPU
power of the machine to handle the required performance. In addition,
it will scale up with the CPUs / memory.

MIMIC Simulator is designed to be highly scalable, and openly publishes
its performance results.

2. customizable responses: in the real world each device returns unique
values for MIB objects. For a simplest example, the sysDescr may be
the same for 2 devices of the same type, but sysName will likely have
different values. Similarly, topology or chassis objects and performance
counters will all have unique values. A commercial simulator will allow
you to easily customize the values for each of the device instances in
your simulation. This allows configuring large topologies such as in
in this post.



3. run-time changes to values: 10% of a devices instrumentation is
static, ie. the vast majority of the MIB object instances will change
value over time. Even further, MIB object instances in tables will appear
and disappear. For example, the interface statistics are highly dynamic,
and log table entries rotate.

A good simulator will allow for a highly dynamic simulation that changes
from one second to another to re-create whatever scenario you require.
Not only that, but those scenarios should be easily reproducible so that
you can implement regression testing.



4. multiple management protocols: in modern environments, SNMP
does not operate in a vacuum to manage your environment, but is just part
of a group of protocols like NetFlow, sFlow, command line interfaces (CLI)
such as IOS and JUNOS, Web Services like REST, SOAP, Redfish, etc.
If your management application uses any of these in conjunction with
SNMP then your simulator should too.

Not only should will a good simulator support the protocols you require,
but the view through any of these protocols should be consistent with each
other. For example, if the NetFlow flows show high bandwidth utilization
for an interface on a router, so should the SNMP counters.



5. record your environment: since it is likely that you'll want to
simulate a real-world environment that you are interested in, recording
that network and importing it into the simulation should be easy.

A good simulator will have a facility to take a snapshot of a real-world
network and create a facsimile without much effort, similar to MIMIC's
Discovery Wizard. Alternatively, you should be able to add onto a simulation,
for example like MIMIC's Topology Wizard.


6. APIs in your favorite language: in addition to a user-friendly GUI
to customize your simulation, a good simulator will have a variety of
language bindings to control the simulator. Since everyone has their
favorite language, the simulator should not force you to become proficient
in one you don't use. MIMIC has Java, Python, PHP, Perl, Tcl and C++
bindings to its API. In fact, the MIMICview GUI is open-source, and it's
PHP implementation is available on Sourceforge.


7. robustness: finally, a simulator should be stable and not crash.
MIMIC Simulator has been deployed in a 24/7 cloud-based CCNA training
appliance for more than 10 years serving thousands of customers.
Add in programmability, it should be good enough that it is invisible, like in
online virtual sales appliances like Cisco's dCloud.









Training on HPE NNMi for your Devops

What you want in a training environment is an on-demand, predictable
scenario that addresses issues faced in your production network, and
allow experimentation without impacting that network.

With the advent of ubiquitous virtual machines (VMs) and network
simulation, training labs can be provisioned cost-effectively by
implementing virtual training appliances on either public or private
clouds. Bundling the management app and MIMIC Simulator on a VM image,
allows the training organization to instantiate as many training labs
as needed at any point in time, and for the trainee to access the
training environment over the Internet whenever and as long as needed.
Realistic self-service training sessions can be provisioned automatically.

With a simulator you can setup any kind of topology such as


to illustrate routing and switching concepts.

For example, in this scenario we have simulated a network of 250 SNMP agents
with MIMIC SNMP Simulator which was discovered by HPE Network Node Manager.
MIMIC simulated devices from different vendors and types in addition
to runtime-customized interconnecting MIB data.

In the following images you can see that NNMi has discovered all the
devices and is displaying a nice topology of various routers and switches.
You can drill down and see the detailed device configuration.









You can also see that it is polling and graphing counters at real-time and they
are increasing at a predictable rate set by MIMIC Simulator. It is very easy to
create customized variations in counters using the MIMIC GUI or a batch script.
In training scenarios, the user usually does not even know that a simulator
is running behind the scenes.