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

Installation and Demonstration

The course is part of this learning path

Building and Deploying a Cloud Native Application
course-steps 4 certification 1 lab-steps 6

Contents

keyboard_tab
Introduction
1
Introduction
PREVIEW3m 32s
Quick Demonstration
Architecture Review
5
Go API
9m 54s
Test and Validation
Summary
12
Review
1m 15s
play-arrow
Installation and Demonstration
Overview
Transcript
DifficultyIntermediate
Duration51m
Students45

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

About the Author

Students11252
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

- [Instructor] 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 stake 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 locations 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: one, it clones both the front-end and API repositories; two, performs a build package of the front-end resulting in the front-end docker image; three, performs a build and package of the API resulting in the API docker image; four, performs a docker poll of the official mongo docker image; five, creates a new docker network named cloud-native demo; six, launches a mongo docker container and attaches it to the cloud-native demo network; seven, downloads the mongo client and then connects to the new mongo instance, and creates the application database and populates it; eight, launches the API docker container, exposes port 8080 and configures it to connect to the mongo instance; nine, launches the front-end docker container exposing port 80; and finally ten, 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 mongo db database and updates the respective vote counter. Finally, if we take a look at the local docker containers we can see the three docker containers that make up our application. 

The front-end, the API, and the mongo db 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 cinema. 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 it's individual components. Go ahead and close this lecture and we'll see you shortly in the next one.