Application Architecture Review
Application Architecture Review
1h 26m

This training course is designed to help you master the skills of deploying cloud-native applications into Kubernetes.

Observe first hand the end-to-end process of deploying a sample cloud-native application into a Kubernetes cluster. By taking this course you'll not only get to see firsthand the skills required to perform a robust enterprise-grade deployment into Kubernetes, 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:

Kubernetes Resources

This training course provides you with in-depth coverage and demonstrations of the following Kubernetes resources:

  1. Namespace
  2. Deployment/ReplicaSet
  3. Pod
  4. Service
  5. Ingress/Ingress Controller
  6. StatefulSet
    1. Persistent Volume
    2. Persistent Volume Claim
    3. Headless Service
  7. NetworkPolicy

Learning Objectives

What you'll learn:

  • Learn and understand the basic principles of deploying cloud-native applications into a Kubernetes cluster
  • Understand how to set up and configure a locally provisioned Kubernetes cluster using Minikube
  • Understand how to work with and configure many of the key Kubernetes cluster resources such as Pods, Deployments, Services, etc.
  • And finally, you’ll learn how to manage deployments and Kubernetes cluster resources through their full lifecycle.


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

  • Create and provision a Minikube Kubernetes cluster
  • Install the Cilium CNI plugin
  • Build and deploy Docker containers
  • Create and configure Kubernetes resources using kubectl


  • A basic understanding of containers and containerization
  • A basic understanding of software development and the software development life cycle
  • A basic understanding of networks and networking

Intended Audience

  • Anyone interested in learning Kubernetes
  • Software Developers interested in Kubernetes containerization, orchestration, and scheduling
  • DevOps Practitioners

- [Instructor] Okay, welcome back. In this lecture, we'll first review a high level architecture of the sample cloud native application, before we deploy it into Kubernetes. If you're already familiar with the architecture, having completed the previous "Building a cloud native application using React, Go, and MongoDB and Docker" course, then feel free to skip ahead to the next lecture, where we actually perform the deployment. Okay, so this review is provided to ensure you understand the messaging and networking requirements, for the sample cloud native application. 

From an end-user point of view, the application provides a web front end, which, allows the end-user to vote for their favorite programming language. When the application initially launches, an AJAX call per your programming language is made to the API, to request the particulars for the display programming language. In this case, three AJAX calls are made, one for each language. After the page is completed loading, the end-user can then click on any of the +1 voting buttons, to vote for their preferred language. This, results in an AJAX call that is directed back at the API. 

The API, as we now know, has been developed in Go, and simply reads and writes to a backend MongoDB database. The view I've presented here, documents the composition of the application. The application consists of the following three main components packaged as containers. The front end: a React-based web application, which provides a voting interface. The API: a risk-based API developed in Go. This provides typical create, read, update, and delete API end points. The front end web application generates AJAX calls, which are serviced by this API. And the database: a MongoDB database set up as a replica set for redundancy purposes. 

The API connects to the database, and performs the required read-writes. The following sequence diagram shows the messaging, as used within the application, when the application first loads. Key points of this diagram are: the browser loads the main application HTML, JavaScript, and CSS files. Then, each programming language component within the interface, makes an AJAX call to the language's name API end point to retrieve the details about the programming language keyed on the programming language name. 

The API in turn, connects to the backend MongoDB database, and simply performs a db dot collection dot find, filtered on the programming language name to return the document that contains all the details about the programming language. A response containing the programming language then flows back all the way to the browser. Finally, the browser renders the full application view. The following sequence diagram shows the messaging, as used within the application when an end-user clicks on the voting button for a particular programming language. 

Key points of this diagram are: clicking the vote button on any one of the three programming languages, will result in another AJAX call being made from within the vote component, within the programming language component, to, the API end point, languages name vote. The API in turn, connects to the backend database, and performs a db collection dot update one, filtered on the programming language name, and, increments the vote field in their respective found document. An update success code is returned in the response, and this is passed all the way back to the originating AJAX caller. The browser then renders and increments the respective votes stubs within the vote component. 

Okay, that completes this lecture, bringing you up to speed on the architecture of the sample cloud native application. Go ahead and close this lecture, and we'll see you shortly in the next one where, we'll document how we intend to set up and deploy the application into a Kubernetes cluster.

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).