1. Home
  2. Training Library
  3. DevOps
  4. Courses
  5. Building A Cloud Native Application

Full End-to-End Application Test

The course is part of this learning path

Contents

Introduction
1
Introduction
PREVIEW3m 32s
Quick Demonstration
Architecture Review
5
Go API
9m 54s
Test and Validation
Summary
12
Review
1m 15s
Start course
Overview
DifficultyIntermediate
Duration51m
Students30

Description

Introduction

This training 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:

https://github.com/cloudacademy/voteapp-frontend-react
https://github.com/cloudacademy/voteapp-api-go
https://github.com/cloudacademy/language-vote-app

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

Demonstration

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

Prerequisites

  • A basic understanding of web based software development
  • Previous exposure to containers and containerisation - 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 containerisation
  • DevOps Practitioners

Transcript

- [Instructor] Okay, welcome back! Everything is now deployed and connected, we are ready to perform a final full end-to-end test of our locally hosted cloud-native application. Let's go for it!

From within the terminal, I'll launch the local Chrome browser and navigate to localhost port 80. And, as expected, the end-to-end solution has worked. This is a fantastic result! We can see that each of the three programming languages have been correctly rendered with their respective details. 

This must imply that the Ajax calls to the API service are working. We can confirm this by inspecting the Ajax calls within the Network view within the Developer Tools component of the browser. Here I'm filtering the network requests, showing only the Ajax ones. Reloading the application, we can indeed see the three Ajax calls being made to the API to retrieve the programming language details. If we select the Java Ajax request, we can see the actual HTTP GET URL, which is going to localhost port 8080, this is our API service. 

We can also see that it has responded with a 200 OK status code, representing success. Selecting the remaining 2 Ajax calls, we can see that they are also directed towards the API service. Okay, let's now perform some voting on the front-end. I'll click the +1 Vote button for Go three times, and two times for Java, and once for Node.js. You can now see back down in the Network pane, the voting Ajax calls being made, each again being sent to the API service, and each succeeding as per the 200 response code. 

From here, let's jump back into the database and see that the votes counter has been updated for each vote that was made on the front-end. Switching back into the langdb database, I'll now query for all documents within it, like so. And here we can see that, indeed, the votes counter on the Go document has been correctly updated with a count of three. Likewise, Java has two, and Node.js has one. Let's repeat this process again. We'll vote two more times for Go, and one more time each for Java and Node.js. 

I'll then again jump back into the mongo shell and re-run the previous query. And, as expected, the vote counters for each of the programming languages are in perfect sync. This is a great result, and shows that the full end-to-end test of our locally hosted cloud-native application has been a success. 

This demonstration has hopefully shown you the power and flexibility that microservice containerization designs provide.

About the Author

Students10951
Labs28
Courses65
Learning paths15

Jeremy is the DevOps Content Lead at Cloud Academy where he specializes in developing technical training documentation for DevOps.

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

Jeremy holds professional certifications for both the AWS and GCP cloud platforms.
 

Covered Topics