Installation and Demonstration


Quick Demonstration
Architecture Review
9m 54s
Test and Validation
1m 15s
Installation and Demonstration

This course is designed to help you master the skills of designing and building cloud-native applications.

Observe first hand the end-to-end process of building a sample cloud-native application using React, Go, MongoDB, and Docker. By taking this course you'll not only get to see firsthand the skills required to create a robust, enterprise-grade, cloud-native application, but you'll also be able to apply them yourself as all code and deployment assets are available for you to perform your own deployment:

Source Code:

Full Install Script:


Learning Objectives

What you'll learn:

  • Understand the basic principles of building cloud-native applications
  • Understand the benefits of using React for frontend web development
  • Understand the benefits of using Go for backend API development
  • Understand the benefits of using MongoDB as a database system
  • And finally, you’ll learn how to package and run microservices as lightweight containers using Docker


This training course provides you with several hands-on demonstrations where you will observe first hand how to

  • Build a React-based web frontend
  • Build a Go-based API
  • Deploy and configure a MongoDB database
  • Deploy the full end-to-end application to Docker running locally


  • A basic understanding of web-based software development
  • Previous exposure to containers and containerization - in particular, docker

Intended Audience

  • Anyone interested in learning how to architect cloud-native applications
  • Anyone interested in using modern development tools such as React, Go, MongoDB and Docker
  • Anyone interested in containerization
  • DevOps Practitioners

Okay, welcome back. In this lecture, I'll first provide a quick demonstration of the end-to-end cloud-native application working locally using Docker. This will give you the chance to get acquainted with the application and technology stack involved and should help with your understanding as we move forward with the remaining lectures we present.

For starters, the build and deployment script for which I'll soon execute will launch a fully functional, locally hosted version of the cloud-native application. The same script is publicly available at the following location seen here. Feel free to download your own copy of this script. Okay, let's clone a copy of this script and run up the application locally like so. It takes approximately a minute to complete.

The basic steps that it performs are:

  1. Git clones both the front-end and API repositories
  2. Performs a build package of the front end resulting in the front-end docker image
  3. Performs a build and package of the API resulting in the API docker image
  4. Performs a docker pull of the official mongo docker image
  5. Creates a new docker network named cloud-native demo
  6. Launches a mongo docker container and attaches it to the cloud-native demo network
  7. Downloads the mongo client and then connects to the new mongo instance and creates the application database and populates it
  8. Launches the API docker container, exposes port 8080, and configures it to connect to the mongo instance
  9. Launches the front-end docker container exposing port 80
  10. Launches the Chrome browser and navigates automatically to a localhost port 80. 

Okay, as you can see now, the script has completed successfully as per the fact that a local Chrome browser opened automatically and navigated directly to the application, which loaded error-free.

Within the application we can simply vote for our preferred programing language. The voting action will result in AJAX calls being made to the API, which in turn connects to the MongoDB database and updates the respective vote counter. Finally, if we take a quick look at the local docker containers, we can see the three docker containers that make up our application: the frontend, the API, and the MongoDB database.

That completes this quick introductory demonstration. If you followed along and successfully launched your own version of the environment then feel free to pause the lecture and play around with the application and explore the underlying Docker setup. If not, then don't worry as I'll demonstrate and document in much finer detail how to do it manually towards the end of the course. 

Okay, that completes this lecture. In the next one, we'll provide a high-level review of the sample cloud-native application and break it down into its individual components. Go ahead and close this lecture and we'll see you shortly in the next one.

About the Author
Learning Paths

Jeremy is a Content Lead Architect and DevOps SME here at Cloud Academy where he specializes in developing DevOps technical training documentation.

He has a strong background in software engineering, and has been coding with various languages, frameworks, and systems for the past 25+ years. In recent times, Jeremy has been focused on DevOps, Cloud (AWS, Azure, GCP), Security, Kubernetes, and Machine Learning.

Jeremy holds professional certifications for AWS, Azure, GCP, Terraform, Kubernetes (CKA, CKAD, CKS).