1. Home
  2. Training Library
  3. DevOps
  4. Courses
  5. Deploying A Cloud Native Application into Kubernetes

Application Architecture Review

The course is part of this learning path

Building and Deploying a Cloud Native Application
course-steps 4 certification 1 lab-steps 6
play-arrow
Application Architecture Review
Overview
Transcript
DifficultyAdvanced
Duration1h 26m
Students43
Ratings
5/5
star star star star star

Description

Introduction

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:

https://github.com/cloudacademy/voteapp-frontend-react
https://github.com/cloudacademy/voteapp-api-go
https://github.com/cloudacademy/voteapp-k8s

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 Kubenetes cluster
  • Understand how to setup 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.

Demonstration

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

Prerequisites

  • A basic understanding of containers and containerisation
  • 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 containerisation, orchestration, and scheduling
  • DevOps Practitioners

About the Author

Students11957
Labs28
Courses65
Learning paths14

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.
 

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