Course Overview

This course provides insight for non-technical stakeholders into Cloud-native computing, Microservices Architecture, Containerization (such as Docker), and Kubernetes. Its goal is to make you understand what they entail, what necessitated them, and the value they can add to your company.

Who should attend

Non-technical stakeholders who need to make or support decisions about cloud-native technology: managers, product owners, project managers, architects moving into a governance role, and sales and pre-sales staff. It is also useful for technical staff who want the strategic narrative behind the tooling they already use.

What you'll learn

• Understand what containers and Kubernetes actually are, and what they are not
• Trace the evolution from client/server through SOA to microservices, and why each step happened
• Appreciate the problems containerisation solves, and the ones it introduces
• Distinguish containers from virtual machines and know when each is appropriate
• Understand the role of orchestration and what Kubernetes offers a business
• Weigh on-premises against managed cloud Kubernetes, and understand cluster sizing
• Recognise the standards and bodies behind the ecosystem (OCI, the CNCF, CRI and CNI)

Course Prerequisites

There are no pre-requisites to this course other than familiarity with general software development and IT.

Outline

Containerization is one of the most important developments in the industry, and its impact is far-reaching. It is hard to imagine what we, as an industry, would have done if it had not come at the right time.

After its inception, containerisation presented a new set of problems that needed to be addressed. This is where, as an IT community, we introduced solutions such as Docker Compose, Docker Swarm, and eventually Kubernetes. Later on, the term cloud-native computing was coined to cover all the above technologies.

The Problem Definition

The long road to MSA

In this first part, we look at the current state of our IT Architecture and dive into how we got here by laying out the gradual evolutionary process. We started this road at the tail-end of the eighties, just before application-centric. This section will cover the following:

• The benefits and challenges of client/server architecture
• The move to application centric architectures
• the birth of services and components
• Values and problems of Component-Based Design
• The force of low coupling (one of the drivers for architecture)
• The era of Enterprise Application Integration (EAI) and Integration Patterns (EIP)
• Event-Driven and Message-Oriented architectures
• The rise of the Service-Oriented Architecture
• Promises made by Enterprise Service Bus (ESB) and the fall of SOA
• the dawn of Micro Service Architecture (MSA)
• Values and characteristic of the MSA

Technical revolutions and eventual freedom

In this section, we take a look at a second driver/dimension that led us to where we are and how it led to the birth as well as the immense popularity of Docker. This journey starts during the height of application-centric architecture in the mid-nineties. Here, we’ll cover the following:

• From CORBA (Common Request Broker Architecture) to the rule of Java Enterprise
• The ages of the (Java) Application Server (WebSphere, WebLogic, JBoss, Glassfish, Tomcat, OC4J)
• The introduction of deployable components
• Finally, competition, Microsoft joins with .Net
• The value for IT and Operations
• The stifling effect on IT Projects
• The rise of (multiple) technology stacks
• The technology matrix hell
• The need for more agility and constrained freedom
• Redefinition of "separation of concerns"

Containerisation

In this part, we explain what containerisation is and how it solves the problems we have discussed so far. Here is what we’ll cover:

• Recap of the problems solved by Containerisation
• What embodies a container ("what's in it"?)
• The role of Virtualization and its role in containerised environments
• The definition of containers and images as well as the relation between the two
• Docker-compose and the depleted soil of Docker Swarm
• The required infrastructure for images
• The impact of the containerisation on the software delivery processes
• Risk mitigated by Containerisation
• Containerisation, MSA, and a call for DevOps

The Crucial Role of Kubernetes

MSA and containerisation have their own challenges when used with traditional IT application platforms and deployment strategies. This is where Kubernetes comes in. In this section, we’ll cover the following:

• Challenges addressed by Kubernetes
• What is Orchestration?
• Choosing between on-premises or cloud-based Kubernetes clusters
• A discussion on cluster sizes
• Security in Kubernetes
• Cluster Observability and monitoring
• Cluster logging (ELK/Elastic Stack, Kibana, Loki, Grafana)
• Resource and performance monitoring (Prometheus, Grafana)
• A quick rundown of popular tools (helm, Kustomize, …)
• A discussion on DevOps and Gitops
• The possible need and role of a Service Mesh

Standardisation

Lastly, we’ll cover the following crucial enablers:

• Appreciate the Open Container Initiative (OCI)
• The role of the Linux Foundation
• Container runtime abstraction: CRI (Container Runtime Interface)
• Container Network Interface (CNI)

Frequently asked questions