This article is part of a mini-series that provides a behind-the-scenes look into how Immersive Labs develops relevant, engaging, accurate, and enjoyable labs to prepare users for modern cyber threats. This offers a particularly useful insight as we begin to release the Lab Builder feature, so you can follow this process to create your own. This is the second piece of the mini-series, where we start on the fun part – development! Before creating labs or tasks, it’s important to establish technical foundations to ensure a smooth development process and avoid unplanned changes later on.
Technical planning
At this stage, we address niche technical details not covered in initial planning but crucial for polished content. Below is an example of the question-and-answer process used for the “Web Scraping with Python” collection.
Should the practical sections of the content be created using Docker, for optimal speed and modularity, or does the subject matter require the use of a full EC2 instance?
As there are no unusual requirements for the technical portion of the collection (such as needing kernel-level access, network modifications, or third-party software that doesn’t run in containers), the labs can run on Docker. This is a benefit not only for the overall user experience, but also allows for image inheritance during development, which will be demonstrated a bit later on.
Are there any tools, custom scripts, or system modifications that should be present across the whole piece of content?
The collection is based around writing Python scripts, so ensuring that Python is installed on the containers as well as any required web scraping libraries is a must. In addition, some considerations for user experience can be made, such as installing an IDE like Visual Studio Code on the containers.
How can task verification be implemented to make sure it’s both robust and non-intrusive?
In the case of this collection, implementing auto-completable tasks may be difficult due to the variety of ways users can create solutions, as well as the lack of obvious traces left by web scraping. Instead, it may be more appropriate to insert task solutions into a mock website that needs to be scraped, which the user can retrieve by completing the task and providing the solution in an answer box.
Understanding the technical requirements for a piece of content helps to bridge the gap between planning and development, making it a crucial step. With some of the key questions answered, it’s time to move on to implementation.
Creating base images
It’s finally time to put fingertips to keyboards and start programming! The first part of implementation creates what all labs in a collection will be built on – a base image. This is a skeleton that provides all the necessary tools and configuration needed for the whole collection, using a concept called image inheritance.
If you're new to containerization software like Docker, don't worry – image inheritance is straightforward. Docker containers use images as blueprints to create consistent, mini-computers (containers). This is useful for labs because it allows you to quickly create a pre-configured container without the overhead of setting up a virtual machine, saving time and system resources.
This is where image inheritance comes in. Docker images can inherit traits from parent images, similar to how you inherit eye color from your parents. Instead of one central image for all purposes, you create a parent image with shared requirements and then customize descendant images for specific needs.
Let’s use the “Python for web scraping” collection as an example again. Think about what kind of things would need to be present in each lab:
- An installation of Python so the user can run scripts.
- A code editor to write the scripts in.
- A mock website for the user to test their scripts on.
The first two of these requirements are essentially the same in every lab; there’s no real need to change the installation of Python or the code editor, and in fact, it would be better to have them all be identical, which would result in a smoother user experience. The third, however, does need to be changed — the specific task requirements are going to be different from lab to lab, and the website files will need to change to accommodate this.
Taking into account the requirements, an inheritance structure like this can be used:
- Base image – Python installation and code editor present
- Lab 1 – Custom website files
- Lab 2 – Custom website files
- Lab 3 – Custom website files
- …
Structuring images this way saves time, disk space, and development work by reusing shared configurations.
Next time…
In part three of this mini-series, you'll learn about the final stages of content development: creating labs, quality assurance, and release.
To be notified when part three is released, follow The Human Connection Blog using the bell icon. Meanwhile, feel free to ask questions about the content creation process or specific collections in the replies. Have you used the Lab Builder feature to make any custom labs yet?
Immerser