mock of work around re-defining a module

After witnessing the attendees around me confused at this step, I think we should add a little more detail or at least a link to the pyang models and the expected behavior. This is only confusing to the less experienced people.

https://learninglabs.cisco.com/tracks/devnet-express-dna/dna-restconf-netconf-yang/06-dmi-05-mission/step/4

Content:
Hint
Use pyang to review the ietf-interfaces.yang model to find the names of the leafs. For a reminder on how to use the tool checkout Introduction to YANG Data Modeling Step 3

Just letting you know... 😄

On the dcloud linux workstations, users encountered a number of file permissions issues on the pre-downloaded github files. Random files were owned by root and lacked rw permissions. We should either instruct users to "sudo chmod -R 777 ." the entire folder or try to fix the upstream image to have consistent permissions. Or, have users clone the repo themselves.

USER STORY: As a host, I need a better storyline about why this event is useful in understanding the DNA tools and technology.

Need to explain the reason that network and infrastructure engineers need to understand the role of APIs from the point of view of an app developer putting pressure on the infrastructure to support mobile devices.

These updates to the slides DO NOT affect the demo or existing labs.

Instructions in this lab:

1. Create a new script “mac_history” that prompts for a mac address and retrieves the historical location data for it.
2. Modify the script to extract the timestamp, coordinates and map hierarchy for each record.
3. Put the results in a Set in chronological order, such that a historical path of the client is created.

Comments:
If we don't provide a script template this looks more like a homework assignment to me. We probably don't have enough time in classroom for students to write a script

#3 is not clear to me that what we are asking student to create ? "set" in python in unordered collection. Maybe more detail and give out an example that what is the output should looks like.

Again this is more like a homework to me, but not a short exercise in the classroom.

Ubuntu host in Cisco DevNet Express DNA Sandbox v2 pod has several issues and needs to be re-imaged.
Issues are:

1. devnet-express-code-samples folder shows contents of iss47 branch. Also there are some uncommitted items in that folder so making a pull request ends with error
2. Main user's home directory (/home/cisco/) has a .ngrok folder which needs to be removed. It prevents multiple ngrok instance from running.
3. bash script in rc.local file needs a minor change.

USER=cisco
BASHRC=/home/$USER/.bashrc
CODE=/home/$USER/Code/devnet-express-code-samples

cp /home/$USER/.bashrc.bak /home/$USER/.bashrc

if cd $CODE && git pull; then
   logger "git pull succeeded"
   echo 'echo -e "Code-Samples were successfully updated.\\n"' >>$BASHRC
   echo 'echo -e "Navigate to '$CODE' and start coding.\\n"' >>$BASHRC 
else
   logger "git pull failed"
   echo 'echo -e "Sorry, but the system was not able to update the code-samples.\\n"' >>$BASHRC
   echo 'echo -e "To manually pull the latest code-samples, please navigate to the  \"'$CODE'\" folder and type \"git pull\"\\n"' >>$BASHRC 
fi 

exit 0

Lab-Ids:

• 00-pre-event-preparation
• devnet-express-np-rest-apic
• others?...

We provide instructions to download the devnet-code-samples repo more than once throughout the track, and when coupled with #19 this causes some participants to rightfully do so and end up with multiple copies of the code on their machines, which causes UX issues like people editing code in one folder and then trying to run the scripts that are located in another (fun troubleshooting experience for new coders).

Downloading the Git repo should probably only be done in the setup module.

For the hosts of events, write up a list of changes being pushed.

Lab-ID: Various

When participants are learning to code (and even if you already know how), it is important that we be crystal clear on 'where you should be' and what files you should working on/with. We have multiple places throughout the labs where we provide path instructions, and they aren't all consistent (a few specific screen shots are included below). Additionally some of our file and folder naming (most notably the virtualenv folder name) causes some confusion.

Screenshots

The 'recommended' code structure in dCloud...

...isn't used consistently throughout the modules.

...which leads to consistency participant issues like:

• What command do I use to activate my virtual environment?
• What is the path to the file that I should be editing?
• When combined with issues like #21 , these inconsistencies cause confusion and scripting errors (participants edit one file, but are actually trying to execute the same file in another folder).

Intuitive folder names

Some participant confusion arrises from how we name some things - most notably the naming of our virtual environments mycode and the devnet-code-samples folders.

Q: Where is 'my code' (meaning the files I have written, edited and contributed to) stored?
A: One might think in the mycode folder, but it is actually stored in the devnet-code-samples.

Q: Where do the packages that I downloaded and installed via pip install (other peoples code) get stored?
A: In the mycode folder. 🤔

Recommendation

We should define a simple but standardized folder structure (for the purposes of these events). Participants may choose to deviate (and that is ok - they can then adapt the instructions to fit 'their environment'), but at least our documentation would be consistent and for those that follow the instructions... Everything should work consistently.

Please address these consistency issues however suits DevNet best. My inputs:

1. Identify and recommend an easily-referencable folder where 'the folder for all of our event content' should live. Could be the system root or the users home folder (the user's home folder is preferable to prevent permissions issues).
2. Consistently name and reference the top-level folder (could be 'dev' or 'Code' or whatever - recommend lowercase and short).
3. Define a consistent and intuitive folder structure within this top-level folder (perhaps consider that instructors and participants might host / attend different DNE tracks).

Examples:

Top Level Folder:

• Linux: ~/dev
• Windows: %HOMEPATH%\dev

Potential Folder Structure(s):

~/dev
|--venv
   |--dna
   |--collab-cloud
|--code
   |--dna
   |--collab-cloud

~/dev
|--dna
   |--venv
   |--code
|--collab-cloud
   |--venv
   |--code

Dear submitter, please provide:

ISSUE TITLE: provide the Lab-ID and short description of what's wrong

• For example:

  Lab 00-prep-nn-sample-id contains typos

To find the Lab-ID, look at the URL of the lab. The lab-id appears to the left of the step number:

• https://learninglabs.cisco.com/tracks/devnet-express-dna /intro-python-programming-devnet-express /00-prep-03-python-primer /step/1

ISSUE DESCRIPTION

In about 50 words or less describe the issue. In addition, include any screenshots or snippets that will help the author know what you want corrected. Try to include:

• snippet of the sentence or code lines that are wrong
• example of what you think the correct sentence or code should be

ISSUE LABELS

Use the Labels to indicate the type of issue (bug, enhancement, etc.) and the severity of the issue:

• Severity 1: broken - the lab or module is broken and cannot be completed
• Severity 2: workarounds - the lab or module works but is very inconvenient or confusing
• Severity 3: minor error

Instruction for this lab:

1. Which Location API will return the mac addresses of all active clients?
2. Create a new script “active_macs” which retrieves the list of active client mac addresses.
3. Copy the python script called active_macs.py from the /module09 folder

Not clear to me that do we want student to create a new script or just exercise the script ?

User Story: As a host of DevNet events, I need a CMX mission that can be performed by multiple users at the same time. LM-4901: Using the Cisco Location Based Services

• The new mission needs to show a use-case that is not limited by the constraint on multiple concurrent users. The way the current mission is written, multiple uses cannot access the CMX notification port simultaneously because of the security policies built in to the CMS server.
• Use Python as the basis for the sample code.
• Indicate revised mission on the module so that hosts know that the module has been revised

Lab-Id: 00-pre-event-preparation
Test Connectivity to the Lab Environment (dCloud Pod) step has the participants connect to some other AnyConnect site rather than their assigned lab pod. This causes participant confusion and adds unnecessary extra steps.

Some will follow the instructions and connect to this 'test VPN' connection and then wonder later why they cannot access their pod resources (now connected to the wrong backend environment).

Others will connect to their pod and then wonder why they cannot access the 'Test Page' called out in the test connectivity step (it doesn't existing in the DNA dCloud pods).

Others might follow all of the instructions and needlessly connect to two backend VPNs.

We should really just have them connect to 'their pod' and thing provide a verification step to confirm that they are properly connected (perhaps have them run the 'lab verification script').

We should provide instructions on how to activate and deactivate a virtual environment. Without this, participants are often receiving 'import errors' because their packages were installed in their virtual environment, which they haven't activated when trying to run their scripts later on in the event.

If combined with a standardized folder structure (see #19), the instructions can be very simple (and should be coupled with a little explanation of how these work):

Linux
source ~/dev/dna/venv/bin/activate

Windows
%HOMEPATH%\dev\dna\venv\Scripts\activate.bat

Deactivation - Both Platforms
deactivate

The content all has an image telling us to tweet at @DevNet, but it should be @CiscoDevNet.

After our event last week we had pretty consistent feedback that the Power Points and labs online were not as closely aligned as would be ideal, and it led to a lot of confusion. In many cases there were some overlapping topics and images, but others were in one or the other. When moving from the slides to a lab, it wasn't clear what lab to move to. The Nomenclature in the slides refers to "Lab X Step Y" but on the site it just has a description for the Lab and within there a few pages which correspond to steps. Labeling each "Lab" with the same number as the slides and having direct links to each step within may help reduce the confusion. If the feedback isn't clear between this and the feedback from San Diego please let me know and I will help clarify.

The procedure on the following page is missing a step for reserving a dCloud pod. The dCloud interface requires the user to select a Data Center before they can see the catalog:

https://learninglabs.cisco.com/tracks/devnet-express-dna/devnet-express-lab-setup/03-environment-01-overview-of-the-lab-environment/step/2

At the next major update cycle, we should upgrade the code on the CSRs in the lab to version 16.5.

This update will require changes to the Module 6 Labs due to YANG model changes.
I have already identified these changes for the non-DNE Learning Labs so the work is fairly minimal.

If any other Module uses the CSR we should investigate the potential impact.

helloworld.py in repo:

mbrainar@MBRAINAR-M-H125: 02-python-primer$ cat helloworld.py 
print ("Helloworld!")

num = 1

if num < 1:
	print ("I'm less than 1!")
elif num ==1:
	print("I'm equal to 1.")
else:
	print ("Goodbye Cruel World!")

print("I always get printed!")

val=134

print("the value is: ",val)

print("the val is " + str(val))

new_val="the value is" + str(val)

While the content of the lab shows:

print ("Hello World!")
num = 1
if num < 1:
   print ("I'm less than 1!")
   print ("Goodbye Cruel World!")

And suggests making changes to the "Goodbye Cruel World" line in the exercises; which is not possible if you use the latest code in the repo.

It says to change all the things in the file. Then attendee gets stuck on certain parts, then realize the next few steps goes over them, but Step 1 gives the impression that it needs to all be completed prior to the next step.

https://learninglabs.cisco.com/tracks/devnet-express-dna/devnet-express-np-rest-apic/05-apic-04-mission/step/1

suggestion made: Remove "Step 1" and keep the "Overall Guidelines".

The current code samples repo uses folder names based on Module x labels:

https://github.com/CiscoDevNet/devnet-express-code-samples

Need to:

• change folder names to match the current module labels
• change the paths in the labs to match the new folder names

In LM-4002: Event Preparation for DevNet Express (for DNA) Step 4, I would recommend as an enhancement, having users execute the following command:

echo "export PATH=\"$PATH:/c/Program Files (x86)/Notepad++\"" >> ~/.bashrc && . ~/.bashrc

which will add Notepad++ to their path and enable them to launch notepad++ with the git bash terminal:

notepad++ filename.py &

Alternatively, it could be accomplished in the LM-4302: Verifying The Lab Environment module, or in each module before starting a lab.

Lab-ID: dna-restconf-netconf-yang

Starting in the Introduction to YANG Data Modeling, and throughout the module we ask participants to use the pyang module to examine and interact with downloaded YANG data models; however, the instructions will not work for users using Windows and the Windows Command Line.

See mbj4668/pyang#310 for more details.

Workaround: Use a BASH shell, like Git BASH, on Windows.

We acknowledge five (5) different scenarios in which participants may be approaching this learning track using at least three (3) different platforms (Linux, Mac and Windows). With fifteen (15) possible environments, clearly communicating what needs to be done, when and how is essential to participant success.

For the setup module, I believe segmentation of these scenarios and platforms would help provide the needed clarity and specificity, and as I see it you have at least a couple of options of how this could be accomplished by mapping the scenarios and platforms (in a matrix) to the Learning Labs and Pages in a Learning Lab constructs:

You could:

• Create a Lab for each scenario with a Page (in the lab) for each platform.
• Create a Lab for each platform with a Page for each scenario.

Using one of these methods would provide the needed separation (separating the instructions for each platform and scenario combination from the others), and (with the help of a little explanation and clean navigation) would provide very clear instructions for an individual participant as to what they need to do - in essence "this is the page for you... do everything on this page."

Hello, I have recently installed Postman and the GUI seems different, I can not see, how to paste/import the token and maybe, because of this I can not set content type

Could you please update part:
LM-4402: REST APIs

• Overview of REST APIs In Progress
  • Step 4. Use Postman to Call the Spark API

Thanks

"Open the supplied code samples (TBD) and look through the various parameters that are used to setup the API call and how the authentication occurs."
I think the goal in this lab is not to learn "how the authentication occurs" since we already asked the same in previous lab.

Over all these missions are not difficult for students to finish if we can provide code samples.
I did finish all exercises with the current scripts we have in repo.

Enhancement: put the scripts for the demo in a Docker container so that it is easier to launch and more predictable in different hosting environments.

• will require docker to be installed on the event hosts' local machine
• will help to reduce need to install all the libraries needed to run the demo
• needs to be able to run concurrent sessions (for when there are multiple events at the same time)

Use Spark room that Chris L. to share review of the updated demo.

In these instructions, the room name should be the exact room the proctor provides for the event. When attendees complete this mission, the data gets posted to the Spark room. The proctor can track who completes the mission.

In the instructions, it doesn't mention this, causing everyone to create a different room, with the proctor not being able to see who completes the mission:

https://learninglabs.cisco.com/tracks/devnet-express-dna/dna-restconf-netconf-yang/06-dmi-05-mission/step/2

At a DevNet Express event delivery of the learning track we make reference to and direct participants to portions of the labs for them to complete as part of the event, and as the referenced portions are a small subset of the online content, the participants have to sift through pages of content to find the portions that we are referring them to... It's a little UX impactful to say the least.

Sometimes, because of the weak linkage between the presentations and the on-line content (see issue #12), participants are looking at the wrong instructions and are confused by the disjoint between what they are looking at and what is being discussed and worked in the room.

Possible Solutions (and I'm sure there are others):

• Create separate lab guides / documents that could be used exclusively at the events (printable docs have also been suggested as an enhancement to the modules - and drafts have already been done by at least one of the Cisco SEs in the UK).
• Create a separate online 'Event Track' that only has the relevant portions of the content that are needed to support the event.

Add instructions to the story to specify what the event host should be showing on their screen (Spark message, etc.).

Hi,

There is a small typo at the following page for 'get_device_id' function definition with the headers assignment line.

https://learninglabs.cisco.com/tracks/devnet-express-dna/devnet-express-np-rest-apic/05-apic-03-apic-em-rest-api-python-app/step/4

`def get_device_id(token, url):

#Define API Call
api_call = "/network-device"

#Header information
headers = {X-AUTH-TOKEN" : token}
'

1. "Install the required Python modules in Pre-requisites" section can be shorten since it's covered
   https://learninglabs.cisco.com:8867/tracks/devnet-express-dna/00-pre-event-preparation/00-prep-01-prep-before-you-go/step/3

Example from - https://learninglabs.cisco.com:8867/tracks/devnet-express-dna/devnet-express-lab-setup/03-environment-03-mission/step/1

'''
Prerequisites
You must complete the Pre-Event Preparation module to perform this module
The Pre-Event Preparation module has necessary steps to install the required applications, development environments, and tools
'''

2. Suggest to modify sample code such that only remember username and password if authentication id good and do the system exit if there is an exception

'''
if not storedCredentials:
username = input("Username: ")
password = input("Password: ")
# storedCredentials = True
print("----------------------------------")
print(repr(restURL))
print("Authentication string: "+ username+":"+password)
print("----------------------------------")
try:
request = requests.get(restURL,auth = (username,password),verify=False)
status = request.status_code
if status == 401 or status== 403:
print (status," Error while Authenticating the User")
else:
storedCredentials = True
parsed = request.json()
print(json.dumps(parsed,indent=4))
except requests.exceptions.RequestException as e:
print(e)
sys.exit()
'''

In Spark room on April 18, Ruth wrote:

Please see email trail about the CMX module. Matthew's revised slides are in the 'slides under development' folder:
[https://cisco.box.com/s/at2s83fruaa4n8rqv9u0mt4skmkb8ftp](CMX LM-4901 Slides on Box)

Need to decide on timescale for releasing the new mission and slides. Suggest the end of this week to avoid confusing the Lima event.

Lab-Id: intro-python-programming-devnet-express

Current use of Git in DNA Track:

• Presently we instruct participants to download the devnet-express-code-samples repo into a directory using the git clone command, and we tell them to use the git pull command to update.

• We provide instruction on using Git after they will have already used it (used in LM-4002 and instruction provided in LM-1201).

• We instruct them on the following commands:
  

• We cover in our instruction:

  • Cloning a repo (which they have already used)
  • Using the pull command to 'update a repository' (which won't work for them after they modify a single file in the repository)

• We don't cover:

  • Creating and checking out a local branch with the checkout command
  • Saving your spot in your local branch with the stash command
  • Committing your work when you have successfully gotten your code working with the commit command
  • Updating the local repo with the fetch command

...which would make for a more beneficial DNE participant workflow.

Recommendations

1. Remove the git lab, and simply have people clone the code as a download mechanism to get the code on their machine (simple but not instructive)
2. Setup the devnet-express-code-samples repo and provide instructions to enable a DNE participant's 'Git Workflow'

Suggestions

• Store the sample code in the main branch
• Create a solutions branch - To store the solutions to the exercises and missions (this could make it easier to keep the solutions up-to-date and if combined with #24 could enable testing and validation of the solutions)
• Instruct the participants on how to create a local branch using either git checkout -b or git branch
• Instruct the participants on how to switch between branches using git checkout
• Instruct the participants on how to stash their changes before switching to a new branch using git stash, and how to commit their changes with the commit command once they have completed their exercise or mission and 'have working code'
• Instruct them on how to update the code in their local repository using the git fetch command

ISSUE DESCRIPTION:

The check_dcloud.py script needs another method to verify that APIC-EM is active and is working properly.

On the Introduction to NETCONF Slide, where it says "Lab #3: Introduction to NETCONF * Complete Step 7 - Querying for ietf-interfaces" The step 7 page says "Example 4", making attendees think they are not on Step 7 and they are on Step 4, feeling a bit lost.

Can we add : " * Complete Step 7 - Querying for item-interfaces (Example 4) " to make it clear?

As we are teaching / helping participants get started with coding, we should strive to set the example for code quality and readability in our provided sample code that participants are reading and working with. Doing so:

• Helps gets participants off to a good start with good coding habits
• Demonstrates our knowledge and expertise, and establishes Cisco as a capable thought-leader in the area of infrastructure programmability
• Following established conventions helps improve the readability and updatability of our code

Python has established coding conventions PEP 8 -- Style Guide for Python Code, documentation conventions PEP 257 -- Docstring Conventions, and guiding principles PEP 20 -- The Zen of Python.

Tremendous global thought has gone into these conventions and principles, and these recommendations net-out in an improved coding experience when coding with Python.

Some of the issues that participants have faced when working with our sample scripts:

• Indentation errors
• Not understanding what the intent of a provided function is
• Not understanding what type of data is being passed into or returned by a function
• Not understanding the flow / execution of one script as compared to previous one
• Not checking for returned API errors, and raising appropriate exceptions
• Silencing errors

Would be greatly mitigated by our adherence these established conventions and principles.

Adherence to PEP8 conventions can be check programmatically / automatically by using a good code linter (like pep8 or flake8).

PEP8 report for devnet-express-code-samples

(dne4dna) dne4dna $ pep8 --statistics -qq ./devnet-express-code-samples/
56      E101 indentation contains mixed spaces and tabs
43      E111 indentation is not a multiple of four
5       E116 unexpected indentation (comment)
9       E122 continuation line missing indentation or outdented
4       E127 continuation line over-indented for visual indent
4       E128 continuation line under-indented for visual indent
2       E201 whitespace after '('
3       E202 whitespace before ')'
1       E203 whitespace before ':'
53      E211 whitespace before '('
9       E221 multiple spaces before operator
7       E223 tab before operator
171     E225 missing whitespace around operator
721     E231 missing whitespace after ','
16      E251 unexpected spaces around keyword / parameter equals
16      E261 at least two spaces before inline comment
15      E262 inline comment should start with '# '
46      E265 block comment should start with '# '
8       E266 too many leading '#' for block comment
34      E302 expected 2 blank lines, found 1
22      E303 too many blank lines (3)
10      E402 module level import not at top of file
204     E501 line too long (93 > 79 characters)
14      E703 statement ends with a semicolon
16      E711 comparison to None should be 'if cond is None:'
330     W191 indentation contains tabs
106     W291 trailing whitespace
17      W292 no newline at end of file
56      W293 blank line contains whitespace
8       W391 blank line at end of file

The indentation issues are of practical concern for DNE participants as indentation is syntactically significant in Python, and when combined with the default editor preferences in the text editors that many participants use (including our dCloud environment), participants receive needless indentation errors when updating and working with our sample code files.

Most of the rest of these reported 'issues' are simply 'Python coding style' errors that if corrected would improve the image of Cisco and DevNet and teach participants good habits, but otherwise are not functional issues.

Asks / Recommendations:

1. Correct the inconsistent indentation in our sample code
2. Provide good minimally necessary error checking
3. As we have energy or interest to do, and especially when creating new / additional sample code, work to adhere to established industry coding practices and style.

Same as previous lab, do we want student create a script from scratch ? Or Modify the sample we provide ?

1. Instruction says: "Modify if necessary (e.g. to your preferred programming.
   language) and run it in your APIC-EM dCloud lab, or from a terminal window."
   Not quite sure about this APIC-EM dCloud lab, not clear to me that where to go to.

2. Adding code to exit script if there is an exception

In 01_get_interface_stats_SOLUTION.py it calls out the following:

message += "    * Packets In: %s \n" % (interface["statistics"]["in-pkts"]["#text"])
message += "    * Packets Out: %s \n" % (interface["statistics"]["out-pkts"]["#text"])

However, running "pyang -f tree ietf-interfaces.yang" returns the following which doesn't list "in-pckts" as an option:

        +--ro statistics
            +--ro discontinuity-time    yang:date-and-time
            +--ro in-octets?            yang:counter64
            +--ro in-unicast-pkts?      yang:counter64
            +--ro in-broadcast-pkts?    yang:counter64
            +--ro in-multicast-pkts?    yang:counter64
            +--ro in-discards?          yang:counter32
            +--ro in-errors?            yang:counter32
            +--ro in-unknown-protos?    yang:counter32
            +--ro out-octets?           yang:counter64
            +--ro out-unicast-pkts?     yang:counter64
            +--ro out-broadcast-pkts?   yang:counter64
            +--ro out-multicast-pkts?   yang:counter64
            +--ro out-discards?         yang:counter32
            +--ro out-errors?           yang:counter32

The solution works, so my hunch is the yang file included in the github repo is out of sync with the version of router we are using.

Need to summarize the changes being released with v2.2.

Several pods typically have APIC-EM crash during the event. To fix it, you can VPN in to the pod, SSH to 198.18.129.100, log in as user grapevine, password C1sco12345, and run reset_grapevine. Be sure to answer NO to all questions and after an hour or two it should be back online. I did not log the exact time to run it.

Modify the story that the demo tells by adding a mockup of a topology that is produced by VIRL, sent as a file through Spark, and deployed with APIC-EM.

"This is around line 80". The function is being called on line 90. For the people brand new to Python, it is very confusing where to go. For people familiar with programming, it's obvious where to go. There needs to be a bit more clarification on how to make this change.

https://learninglabs.cisco.com/tracks/devnet-express-dna/dna-restconf-netconf-yang/06-dmi-05-mission/step/3

Content:
Within the function get_netconf(xml_filter) function, implement the correct NETCONF operation. This is around line 90.

We repeatedly do some of the same information retrieval exercises over and over:

• Copy and paste your Spark Access Token into your script (bad practice - storing credentials in code)
• Get the Room ID of the Spark Room to which you want your script to post
• Get the IP address / hostname of XYZ host...
• Get the Username and Password for XYZ host...

All of this information could be collected and stored once in the participant's development environment, which would reduce duplicate work for the participants and streamline some of the scripts (which could for example simply access the participant's SPARK_ACCESS_TOKEN environment variable for example).

We could provide a sample environment_variables.sh and environment_variables.bat pre-populated with the dCloud environment information (hostnames, credentials and etc.) and placeholders for the participant's unique information (Spark Access Token, Room ID, etc.). These files could then be easily sourced / executed to setup their environment in preparation for them running their code.

Here is the lab I mentioned: https://learninglabs.cisco.com/tracks/devnet-express-dna/dna-cmx-mse/09-cmx-03-cmx-and-mse-deep-dive/step/1
we will need multiple ports open for the listener. When I presented the session last week, I had only one port open.
It is frustrating for the attendees not be able to complete the lab.

There have been several requests from the field for the DNA track to include coverage of Meraki cloud-managed APIs in addition to the Cisco locally-manage infrastructure APIs. This could be done in a couple of ways:

1. Add coverage of Meraki APIs to the relevant existing modules (perhaps as additional learning labs).
2. Add additional modules that specifically cover Meraki APIs. Then, the local event team can plan which module to deliver as part of their event (enabling some event agenda modularity).

The following APIs may be of interest / value to the DNA Track:

• CMX Location API
• Dashboard API

So far, the greatest volume of field feedback has been in requesting coverage of the Meraki CMX Location APIs.