Docker Containers and Kubernetes Fundamentals Course Summary

gee Barrette teaches us Docker containers and kubernetes fundamentals course for beginners ghee is a developer

and trainer with more than 25 years of experience he is a Microsoft MVP frequent conference speaker and was the

leader of the montreal.net user group for more than 23 years all this is to say he is the perfect person to teach

you about Docker and kubernetes [Music] welcome to this Docker containers and

kubernetes fundamentals training course my name is gibaret and I'll be your host in your Learning Journey Into The

Amazing World of containers I'm a full-time trainer with a developer background and I'm based in Montreal

Canada and that's where my strange accent comes from I'm certified on kubernetes and also on

terraform Azure AWS and Google Cloud I'm very honored to be a Microsoft MVP in the Azure expertise and a

digitalocean navigator you can reach me via the contact page and on Twitter

what should you expect from this course you will not become an expert just by taking this course this is an

entry-level course that will provide you with a strong containers and kubernetes Foundation

and you'll gain enough knowledge to make sound decision at work or in your projects

throughout this course you will find lots of Amazon activities to practice what you've learned

you will use Docker and kubernetes locally on your PC or Mac so there's no requirement to have an account with a

cloud provider are there any prerequisites for this course not really if you're a developer

a devops specialist an ID Pro or even a technical manager that's totally fine no previous Docker or kubernetes knowledge

is required we will cover a lot of ground you will learn about containers Docker

and D Docker registry you learn about the kubernetes objects like pods workloads and services

that's a lot of material and the goal here is to get you from zero knowledge to a kubernetes ninja

well at least provide you with enough knowledge to Aspire being a kubernetes ninja

I want to say a big thank you for learning Docker and kubernetes using this course

if you like the course you can help me by making a small donation this is the link to my buy me a coffee page

you can of course buy one of my other courses where you'll learn to run containers on different Cloud providers

services and use a managed kubernetes cluster in the cloud and finally I wish you all the best in

your Learning Journey [Music] let's see how to set up your laptop or

PC for this course you need a laptop PC or Mac with either Windows 10 Mac OS or Linux

if you have a Mac with an apple silicon most tools should run perfectly I will use Visual Studio code with the

docker extension to help build create and run containers vs code is a free IDE that runs on

Windows Mac and Linux on Windows and Mac you'll need Docker desktop with kubernetes enabled

on Linux refer to the documentation on how to install Docker and kubernetes on your distro

you'll need a Docker of account and a few easy to install tools refer to the setup instructions located

below this video the lab files are located in a git repo on GitHub

simply open this URL in a browser click on the code button if you have git installed on your

machine you can type git clone with the link displayed here and if you don't have git simply click

on the download zip button to download the code as a zip file [Music]

let's talk about the microservices concepts if we head to Wikipedia and take a look

at the definition that we find over there it says that it's a variant of the service oriented architecture or SOA a

structural style slash architecture and that it arranges in application as a collection of loosely coupled services

so instead of a large monolithic system we have multiple smaller pieces in a microservices architecture services

are fine-grained meaning that each of them have their own responsibilities and the protocol use are lightweight

like an API exposed over HTTP or grpc for example if we look at the monolithic

architecture these systems were usually built as one single unit

an IDE would group multiple projects and we would compile the whole thing as one single unit

they were also deployed as a single unit so we would need to copy everything all the files on on a server

and if we had to scale the system we had to spin a new VM and copy deploy the whole system on that VM and same for a

third and a Ford server an example of such a monolithic architecture is a treaty application

even though the system was clearly separated into layers it was all tightly coupled from the web

project we had to make a reference to the business layer project and the whole system would run in the same address

space with macro Services we break our big system into smaller parts each with its

own responsibility so let's say we have a class that deals with identity in our business layer we

can extract that code and place it in its own microservice we can then scale each of these smaller

pieces independently from each other there's no strong bound since we expose functionality through an API

they can be written by smaller teams and each can use their own programming languages like go PHP C sharp

and domain-specific data can be stored in separate databases so the way we would deploy a monolithic

system is by deploying everything on a server all the dlls files needed to run the system

we had to scale the deploy everything on more servers now let's compare that to microservices

well microservices are deployed independently each can scale independently also

need to scale back one service no problem so if you have an existing monolithic

system how can you transform it into a microservices architecture well you need to break it into small

units like the code that dealt with the identity in the in our business layer Martin Fowler author of the patterns of

Enterprise application architecture book documented the way to achieve such a transformation using the Strangler

pattern let's say our identity code is here in the Legacy system

we can place a facade to Route the calls to it migrate the code and have the facade route the calls to

the new macro service at some point as we go we will end up with less code in our Legacy system

and when democracy and it's done we can get rid of the facade this pattern is very useful and you can

learn more about it using the link in this slide and this concludes this lecture on the

Marco Services Concepts [Music] let's talk about Marco Services

anti-pattern because it's a thought Rosie I know it's kind of strange to talk about what can go wrong right away

but I think it's very important first of all it's not some kind of magic pixie dust

that you can sprinkle on top of a zigzing system and boom you get a beautiful Marco Services architect

system it takes efforts and maturity to achieve this

from one monolithic system you'll end up with a bunch of smaller pieces and that can add extra complexity

a change to a microservice can have a domino effect and take your system down and what about securing all of these

microservices it's also essential to use or introduce new processes in the organization

like devops Ci CD and testing but be careful and don't try to implement everything at the same time

it's a recipe for disaster take it step by step and make sure you have metrics in place to validate each

of these steps and this concludes this lecture on microservices antibatterns

[Music] let's talk about the microservices benefits and drawbacks

since each microservice runs in its own address space there are less chances that if one of

them goes down it takes the whole system down with it a microservice runs on open source

Technologies so there's less Fender lock-in since they are smaller in most case they

are easier to understand and that makes them faster to deploy and also easier to scale

like we saw in the anti-pattern section there are some drawbacks complexity is added over mother's

existence to resolve to her complexity issues so make sure your team is well trained

and has made some proof of concept and make sure to start small adding one piece at a time

testing might appear simpler since there are less functionality in a microservice to test

but make sure to test the whole system deployment may appear simpler but one update can impact many Marco services

and have a terrible domino effect ready to manage multiple databases calls between macro services will go

through apis and this will add a bit of latency to all calls so make sure you test for that

this key transition server will appear you'll make a call and it will fail or but try again 50 milliseconds later and

it will work so make sure to implement some retry strategies in your code or by using a

service mesh instead of one big point of failure you'll end up with multiple ones can

your system survive if one microservice goes down and what about security

are you okay for all these microservices can see and talk to each other so yes complexity is introduced for

solving complexity issues and this concludes this lecture on the macro Services benefits and drawbacks

thank you [Music] let's Now understand what is cloud

native you may have heard the term Cloud native before

but what it is exactly it's a way to architect and build complex systems taking advantage of

modern development practices and the use of cloud infrastructure if we head to the cloud native

Foundation website and look at the definition we see that it's quite a long one

so let's break it into smaller parts Cloud native uses containers service meshes microservices immutable

infrastructure and declarative apis we'll cover containers service meshes and macro services and the concept of

immutability in this course but not how to build apis immutable infrastructure means that we

usually never update something but we replace it with a newer version Loosely coupled systems mean that the

functionalities are exposed through apis observable with the use of metrics creation and updates are automated

and instead of making changes once every six months we deploy eye impact changes on a freaking basis

and finally we use a series of Open Source projects to run our system when the cncf says to use open source

projects they are not kidding this cncf landscape graph shows a ton of Open Source projects that you can use

but don't worry you don't have to use them all the challenge really is to identify

which one to use in the context of what you want and try to achieve and this concludes this lecture on cloud

native head to the cncf website for more info [Music]

let's go deeper in the cloud native Concepts Cloud native is about Speed and Agility

the user wants new features right away without any downtime and the business wants faster release of

feature to stay competitive a cloud native application architecture starts with clean code

using domain-driven design techniques Markle services and kubernetes

this course is all about microservices and kubernetes feel free to explore the concepts of

clean code and DDD on your own with Cloud native we need to change mentalities

infrastructure becomes immutable and disposable it is provision in minutes and Destroy

as fast it is never updated but it's replaced with newer versions

traditionally we would care about our virtual machines we would patch the OS update the apps

with containers we create newer version with the software updates destroyed the previous running ones

and replace them with the newer ones so the containers that you'll run will be more like cattle than pet

of course this Cloud native thing is a lot easier when starting a new project a blank page or a green field

however it's still possible with Legacy projects I really like the cloud native

Foundation trail map because it breaks the journey to Cloud native into smaller measurable objectives

you can set your own performance indicator to measure each steps to ensure a smooth Journey

so let's take a look at the first steps your team must first learn how to cantonerize your application

the developers and the IT Pros must know how to deploy and monitor containers you need to automate deployment through

the use of continuous integration and continuous delivery techniques and tools you need to use an orchestrator like

kubernetes and maybe deploy your application using L charts

then you need to add observability so you can understand what's happening in your kubernetes clusters and be reactive

use tools like service meshes to provide more functionalities inside your cluster Implement security through policies

and wow these were just the first six steps Now understand that you don't have to implement all of this and especially

not at the same time I really like this trail map because it breaks the journey into smaller steps

that the management can understand and measure and this concludes this lecture on the

cloud native Concepts [Music] let's take a look at the cncf website

the website is located at cncf.io and from there you can take a look at the various projects maintained by the

cncf information about on how to get certified

Community Information like the conferences that the cncf organized each year

so let's go back to the projects menu and you'll notice that projects are categorized in three categories sandbox

incubating and graduated let's click here on this the second menu here and let's scroll down to the bottom and

here you get the information about the meaning of these three categories and basically that's their maturity level

sandbox projects are mostly newer projects uh well graduated projects our projects set conservatives Enterprises

are more likely to use so let's take a look at the graduated ones we found here kubernetes

Helm Jagger so let's click on kubernetes and basically that will show you the the project website

let's take a look at the incubating ones here we find Linker D grpc let's click on grpc you can get more information

about the grpc all right let's go back to this menu remember the

trail map that I mentioned in the previous lecture well here it is cloud native trail map

here's the nice diagram you can get more information you can get send that to friends colleagues

and here's a link to the landscape diagram here it is it's super huge

Let's uh let's click here on kubernetes and here we get very interesting information

well you get the repository where the project is uh is stored you get the number of stars and the activity number

of commits here you get you get the website address and also the Twitter handle here

so you should follow the Twitter feed of the project that you're using so let's close this one

let's click here on hell again website

uh repository number of stars activity and the Twitter handle and this concludes this look at the cncf

website thank you let's now talk about the containers

Concepts containers containers containers they are everywhere but what are they

exactly a container is a unit of deployment it contains everything needed for the

code to run so the compile code the runtime system libraries and this is system tools

you take a container push it on a server and it should run of course it can have some external dependencies like a

database or a cache but the code deployed in it should run as is so why use containers

because it is faster to deploy something small than something big like a complete monolithic system

uh they use fewer resources they are smaller and since they are smarter you can fit

more on the same server when using cicd techniques they are a lot faster to deploy

you can run them anywhere and they are isolated from each other meaning that if one fails

it will not take the whole system down with it so what exactly is virtualize

let's compare virtual machines with containers a VM runs on some kind of Hardware where

an OS is installed the OS hypervisor will let you create a virtual machine

where you will install in OS so basically DVM virtualized the hardware

and what's happening when a VM starts well you see the BIOS coming up and then the OS boots up

and what about the size of that VM let's say we have a Windows Server VM it can take 12 gigabytes of RAM and 500

gigabytes of hard drive space and how long does it take to boot well depending on multiple factors

something like 5 to 10 minutes now let's compare that to containers we still have the hardware and the OS of

course there's a container runtime installed uh in the OS

and containers images are run in memory now compared to a VM a container does not have to boot

because it will use the host OS kernel this means that container starts in seconds because they don't have to boot

they also use a lot less memory and hard drive space since there's no OS a small container can take a hundred

megabyte of hard drive space and run in 64 or 100 megabyte of RAM

so VM and containers virtual machine have a larger footprint they are slower to boot

ideal for long running tasks container are lightweight they're quick to start they don't have to boot they're

portable and they're ideal for short-lived tests because they you can spin one super fast

so are containers replacing virtual machines our virtual machines obsolete

absolutely no containers are just another tool in your toolbox and you need to find the right use case

for them and also for VMS if you're old enough you must remember what the telephone booth is if not well

before cell phones we used to make phone calls in these spoons by dropping a dime or a quarter anyways

using a telephone boot analogy you can pack more containers on the same server than what's possible with virtual

machines containers are made of layers you start with the base OS

add customizations and add your applications let's take a deeper look at this

screenshot the docker pull command retrieves and download a container image

as you can see each layer is downloaded individually notice that each has a unique ID

and that for the first ones Docker says that they already exist why is so Docker uses a local cache to store the

container's images and if a layer already exists it will not be downloaded again

the benefit is that if you pull version 2 of an image Docker will only download the layers not present in its cache

one of the goal when creating container images is to create them with the smallest number of layers possible

later on we'll see techniques on how to achieve that now can you write on these layers

well no except for the top one because it is read right the lower ones are read only

another concept is the container registry it's a centralized repository where you

deploy the container images you create think Gita but for containers Docker as one called Docker up that

provides public and private repositories and all major Cloud providers have container registry services

the last container concept is the orchestrator an orchestrator allows us to manage

scale monitor the containers that we run on our servers you can install your own

or use a managed cluster offered by one of the cloud providers like AWS Azure Google Cloud

we will come back to the orchestra Concepts after we have a better knowledge of containers

and this concludes this lecture on the containers Concepts [Music]

let's Now understand what is docker so what is stalker that may seem like a simple question but there's more to it

there's Docker the company and Docker the platform document thinks the Mobi project an open

source container runtime that follows the specs from the open container initiative

doctors sold its Docker Enterprise division late 2019 to a company called mirantis

so if you want to buy Enterprise support or get certified with docker you have to go through morentis

Docker provides a container runtime that runs on Mac windows and Linux a command line tool to create and manage

a containers a Docker file format for building containers

and interestingly Windows lets you create both windows and Linux containers foreign

if for some reason Docker doesn't seem to work on your machine try restarting it by using the restart menu from the

system icon on Windows or by clicking on the debug icon in Docker desktop on Mac and windows and

clicking on restart Docker desktop is very stable but I had some issues when my laptop was coming

back from hibernation but that was a long time ago and I haven't had issues for a while

and this concludes this lecture on docker [Music]

the easiest way to run Docker on your machine is by running Docker desktop it's a free download available on

docker.com so you click here on get started and you download the version for your OS

so Windows Mac Linux here now if you're running Windows uh check the version of Windows that you're

running if you're running Windows 10 version 2004 or a later version

you can run what what's called windows subsystem for Linux version 2. so wsl2 basically it allow you to run a Linux

distribution right into your Windows installation so Docker desktop can run its container by installing a virtual

machine inside hyper-v or if you have wsl2 install it will it will install that virtual machine

inside the Linux distribution and everything will be a lot faster so that's the preferred way so just to

prove a point here I'm going to launch my hyper-v miniature

and as you can see I'm not running any virtual machine so my Docker desktop installation uses wsl2

you'll find a link to this installation guide in the modules notes okay so let's take a look at the docker

desktop I'm running Windows as you can see I can see my Docker desktop system tray icon here so for Mac User it'll be

at the top of the screen of course I can right click on it and let's select dashboard

all right so here I can see a list of um containers that are currently running I can stop them restart them delete them

I can see a list of uh images that are installed on my machine here we'll come back to that later on there's a gear

icon here that's the setting icon and in the general section here you can see that

wsl2 is enabled so that's why Docker desktop doesn't use a Now preview virtual machine it uses the wsl2 to run

the VM and there's the kubernetes menu here if I select it I can see that

kubernetes is enabled so when you check that Docker desktop will download additional containers to run kubernetes

right onto Docker desktop here so very useful there's a bug icon here which is the

troubleshoot icon here so if at some point you're issuing Docker commands and the don't work or

something's wrong uh running Docker Docker commands you can click here on the restart button

here you can see my name here it means that I'm currently logged and if I right

click down on the system play icon you can see that I'm currently logged in and I have the option to to sign out so

what uh username and password did I use to to log in when you downloaded the uh the docker

desktop you could have created a Docker account or a Docker Hub account so that's the same username and password so

if you go to up.ducker.com and you logged in well that's the same account that is used

here in Dr desktop thank you [Music]

let's take a look at your first Docker CLI commands now throughout this course I will

introduce you to various commands I will list them in what I call a cheat sheet list like what you find on the

slide I will briefly explain what the commands are for

and that will be followed by a concrete and Zone demonstration so when you install Docker desktop on on

your Mac or PC it also installed the docker CLI tool our first command is Docker info

this will display some information about the docker installation on your machine Docker version will display its version

and Docker login will log you into a Docker registry by default this login command will log

you into Docker Hub the registry from docker and this concludes this lecture on the

docker CLI [Music] alright we need to open a new terminal

window into Visual Studio code so let's select a terminal new terminal or you can use the shortcut Ctrl shift back

tick key all right this will open a terminal window and let's take a look at the

commands that we will run they're really basic it's just for testing that our Docker

installation is working correctly so let's type Docker info this will give me some information about

my current installation what's happening I have 47 containers three stuff 44 running 25 images and so on and so on so

information that that is quite useful for debugging purposes I can see that the virtual machine running that running

Docker desktop is running as to CPU it has two gigabytes of memory allocated all right sounds good let's uh type now

Docker version and this will uh give me some information about the version number of

different parts of Docker desktop so again useful for debugging purposes these are not commands that you will run

on a day-to-day basis but they're quite useful for troubleshooting the last command is Docker login so I'm just

going to type Docker login without any username password see what's happening and well the command says that I am

login successfully why is so well if I right click here on my Docker desktop I can see that I'm already

logged in so that's why I didn't have to input or type any username password I was already logged in

[Music] let's now see how to run containers the docker pull command lets you

download an image from a registry Docker run will execute an image in memory as a container

if the image is not present in the docker local cache it will be downloaded automatically

using run with the Dash D flag will run the container in the background giving you your comment prompt or

terminal back the start command will run a container in the stopped state

Docker PS will list all the containers currently running and add the dash a flag to also lists

all the stopped ones Docker stop will stop a container running but the container will still be

in memory we will see how to remove them from memory in a few minutes

Dr kill will well kill a container that might be stuck in memory you usually don't use this comment but

it's useful to know Docker image and spec will give you some information about an image very useful

for debugging purposes so you may notice that we have two parameters here

one is called image name and the second one container name so what's the difference

the image name is the name of the image as you find it in the container registry and the container name is the name of

the running container so you run an image using its name and then interact with it using the running

instance name the Run come in as an optional flag call dash dash name that lets you specify

your name if you don't specify one Docker will Auto generate one for you

you can set limits on the memory and the CPU that the container can use when using the Run command

so how do you run a container using the docker run command you specify the image name as found in the container

registry you specify a name for the running instance

and with the published flag you map a port from your local OS to the port that the container is listening to

you can list the running containers using Docker PS notice how we stop the container by

using the running name and not by using the image name then we remove it from memory using the

remove or RM command containers are not black boxes you can attach a shell to your terminal and run

commands that will execute right inside the running container by using the dash it switch and the name

of the program you want to run a Windows container well you can run Powershell

using the docker container exact command you can attach to a running container here's a screenshot showing the docker

run command and notice the terminal problem changing when attached to a container

so how do we clean up things the remove command lets you remove a container from memory

but first it must be in the stop state for the command to work here's the remove command getting a list

of the stopped container and removing them all the images that you pull will be cached

locally you can get a list of these images using the docker images command

use the remove image or RMI command to delete an image from your machine after a while you may end up with a

bunch of images to do some spring cleanup I use the system prune command

this will delete all the image currently not in use so be careful using this command

and this concludes this lecture on the docker CLI [Music]

let's now run our first container we'll run an engine X web server so something pretty basic that'll be perfect for this

this lab all right let's open a terminal so terminal new terminal or Ctrl shift back tick

perfect so we'll run disk command so let's take a look at the command first

so I'm going to run a Docker run and let's go at the end of the command this will be the image that will run so

an nginx image we'll give it a name so the name will be web server that will

be the name of the running instance will map local All Sport 8082d or that the container is listening

to so port 80. n d 4G decimal so we can get our Command Prompt or terminal prompt back so let's

run this ha something interesting is happening unable to find image nginx latest and

you see that the docker as pull all the different layers locally here so now if I issue a Docker PS

it will list the containers that are currently running so I have uh three containers running so the kubernetes

dashboard and the metric server here so don't uh look at these let's focus on this one so this is the containers it is

that we just launched the nginx image here it started 30 seconds ago

we can see that the port 8080 local levels is mapped to the port 80 here and the name is web server

so let's launch a web browser and let's type localhost 8080 the container is actually running

fantastic all right so we can get a list of the images installed on your machine here by using

Docker images so I have a bunch I may have a lot more than you but let's focus on the last one here uh nginx the tag is

latest image ID and this is the uh the size all right fantastic let's try to connect

to uh to it so we'll issue a Docker container exact we'll give it the the name so the

running instance and the program we want to run so look at the The Prompt now

root at some some ID so the ID is the actual container ID so I'm logged in as root on that container so now I can

issue some some commands so let's do in the last let's thy fell less been to see what's

in there so different commands so I'm connected to to that running container that's pretty uh pretty cool so I can

issue commands look at the logs if any and do some troubleshooting so this is super useful

for debugging purposes uh we'll use that a lot in the various steps that we'll do together

all right let's get out of there by typing exit all right you can just clear my screen

here so our container is running how do we stop it we use the docker stop command

but look at the the parameter that we use the name of the container that we use we

use the running instance name not the name of the image so that's pretty important here

Docker stop web server all right but the container is still in memory if I do a doctor PS

it's not listed anymore as you're running container but if if I type darker es Dash a

ha for all I can see that my my container is still in memory here so I need to remove it from uh from

memory so we'll use the docker RM and the name of the running instance so RM for remove

and now the container is no longer in memory awesome now

the container is still well the image that was used to create the container is still on my machine

so if I type darker images you see it's still it's still here so that takes 133 megabyte of this space

if I want to get rid of that I use the RMI so remove image command and the name this time of the image not the name of

the running instance because none are running right now and you see all the layers

have been deleted [Music] let's now see how we can build

containers Docker build that you create an image using a Docker file

if you run the command in the same folder where the docker file is located simply use a DOT as the file name

if the file is located in a different folder specify the location using the F flag

the tag command let you assign a name to an image this tagging has two parts

a name and a tag the tag is usually used to specify the version number

so what is a Docker file well it's a text file listing the steps to build an image

here's the simplest Docker file I can imagine two lines

the from command specified the base image when building new images you always

start from something already existing in this case an image with the nginx web server using the Alpine version

and then the copy command copies everything from the current folder to a folder inside the container

using the build command we create a new image specifying the docker file remember to use the dot when the file is

located in the same folder here's another one this time a little bit more complex

it is used to create an image running a node.js app let's take a look at it

the from command specify the base image using the Run command we run the package manager inside the container to install

node.js next we copy all the local files into a folder named SRC inside the container

we use the Run command to do an npm install we then had some metadata in this case

we tell the container to listen on port 8080 and finally we tell the container what

to run when starting so as you see this Docker file contains the stats needed to run our node.js app

we saw what tagging was a moment ago let's explore this again using the docker tag command we name an

image using a name and optionally a tag if you don't specify a repository name it will default to Docker Hub later on

we'll see how to push images to different repositories and we'll have to specify the Ripple's Journey name when

tagging our images and this concludes this lecture on how to create Docker images

[Music] let's see how can Visual Studio code help us build and run containers

so what is visual studio code and why talk about this tool in this course well it's a text and code editor

it's free and open source it runs on Windows Mac and Linux and you can download it for free using

this link so you will work a lot with text files creating Docker files and later on

Docker compose and yaml files a tool like vs code will help you because you can install plugins that

will make your life easier using a different text editor no problem in vs code you can install plugins by

clicking on the extension icon in the left menu then you search for Docker and install

the extension from Microsoft the extension lets you add Docker files to your projects using the command

palette open it using the view menu or type Ctrl shift p

type Docker add and select add Docker files to workspace the extension will ask you a few

questions and we'll create the docker files for you

vs code has a built-in terminal where you can type commands or you can run commands using the

command palette here's another example when running a container

and when using the command palette there's no magic there the extension will simply issue a command in the

terminal but sometimes it's a great way to learn creating Docker files is okay but what I

like the most is the UI provided by the extension helping me manage my container so if you click on the docker icon

you can see the images installed on your computer and you can even see the containers

currently running right click on an image to manage it same thing for the containers currently

running very very very useful and this concludes this lecture on vs code

thank you let's now use Visual Studio code to containerize a node.js express

application so I already installed the docker extension in Visual Studio code but

let's take a look at it so if I click here on extensions and let's search for docker

here it is that's the one from Microsoft almost 6 million install at the time of recording

so that's the one all right so let's go back to our files so I have my node.js application here if

I click here on package.json [Music] the name of my application is my Express

app so that'll be important in a few seconds all right so let's first add the docker

file to our project so we'll use the tooling provided by the extension to do that

we'll go to the view menu command palette or you can use the shortcut Ctrl shift p

right and we'll type Docker add and there are two options here Docker files or Docker compose files so we haven't

looked at the docker compost file so let's select the first one Docker files the extension hack is asking us about

the application platform so it's a node.js application but it can generate Docker files for net python Java C plus

plus go and Ruby apps so let's select node.js all right and next next it's asking us

where is the package.js file so here it is it set the root of my application so I'll select this one

the port that the application is uh listening to 3000 perfect and do I need the optional Docker

compost file no not at this time all right so the extension quickly added a the docker file and also the docker

ignore file and also a folder for vs code so let's take a look at the docker ignore basically it's a list of files

not to deploy in our container and the docker file has been created for me to use a node base image it copies

everything into the Container the image and expose port a portrait 3000 perfect so let's now build this image

so we'll go back to the command palette view command palette Ctrl shift p and this time we'll search for Docker build

all right here it is Docker images build image all right so I just issue uh the command

and look look at what's happening the extension is not a black box uh issuing some crazy or strange uh

commands in the background it's just issuing a a Docker Bill command here

and remember a few seconds ago I mentioned that the name of the application in the package.json file is

is important well that's the name of our uh of our application here so the extension use it to generate the name

for my image all right it's just a Docker Bill command nothing

fancy but using this extension is a great way to learn about some uh some commands that you may want to use at a

later time from the terminal prompt okay terminal will be reused by test press any key to close it let's press

any key all right the image has been built let's run it now so view command palette

okay Doctor run so we'll use the first one and uh there's a list of my images

and here is my Express app perfect run that

select image that's the latest the tag latest perfect and look at what's happening Docker run

sport 3000 to the port that the container listening to so nothing fancy here is uh it's a comments that you can

type yourself but uh the extension to that are for you so if I start my browser local ocean I go to

Port 3000 there it is so that worked

perfect let's now close this let's now use the UI provided by the

extension so in the left menu let's click on the docker icon here and from there you have a list of the

running containers the images and the different Registries that you connected to all right so here's our Express hat

my Express apply it is and it's running name the instance name is called magical underscore Direct

uh why is so well when we issued a Docker run command using the command palette

the extension didn't provide a name so uh one was generated automatically by by docker

so from there I can view the logs attach shell inspect open in a browser so if I select

that there it is that's my app listening on Port 3000

uh I can stop it restart it remove it so let's uh let's remove it here so are you sure you want to remove

container yes it's not in memory anymore it's not running anymore

but if I look at the list of the images that I have here it is my Express app so I can right click on it

and I have a few options I can run it inspect it pull push tag and even delete it so let's let's run run it

okay and you see at the top my Express app and look at the name gifted underscore

El beckyan because if you look if you uh inspect the docker command that was issued

by the extension there's no name provided so Docker generated one for us

all right so let's close this we can stop or remove it from memory and if we no longer need the image we

can just remove it here are you sure you want to remove the image blah blah blah

okay let's remove it and it's gone so what's happening in the background is

that the extension is simply issuing a Docker remove image RMI to to remove the image from from this so nothing nothing

really fancy the extension it's not a black box that is issuing some strange commands it's just regular and Docker

commands but I really like the the UI provided here and so instead of uh typing uh okay

let's uh let's try this let's um let's clear this and let's type Docker

images here's a list of my all my images but here I have a nice UI listing all the

the same images here so sometimes it's it's easier having a little UI to help you accomplish some tasks other times

it's easier issuing the commands from the terminal or the command prompt so it's up to you you can use the UI or The

Terminal thank you [Music]

let's talk about data persistence containers are ephemers and stateless so you don't usually store data in them

of course you can write data in a container but if you destroy one or if it crashes any data stored in it will be

lost so it's okay to write some log files or scrap data that you don't want to keep

as long as you understand that you will lose these files at some point in time to purchase data you need to store it

outside the container in what we call a volume a value Maps an external folder or even

a cloud storage service to a local folder inside your container so your app sees a volume just like any

regular folder the OS in this diagram represent the server or the virtual machine where the

container is running as you can see a local folder is mapped to the VM file system so they are stored

in a volume where survive a container restart or crash there's still a chance that we can lose

the data if the VM crashes so later on we'll see how we can use some type of external storage provided by the cloud

provider but first thing first in the next lecture you'll see how to create a

volume that maps to a VM file system and this concludes this structure on data persistence

[Music] um let's see how to create volumes

here's a cheat sheet listing the docker commands for managing volumes Docker create volume will create a new

volume LS will list all the volumes volume and spec will get you information

about a volume remove will delete a volume destroying all the files storing it

and volume prune will delete all the volumes currently not mounted or not in use

so be super careful careful using this command alright

you first need to create a volume using the docker volume create command then when you run a container you need

to use the V switch or to volume a parameter specifying the volume name a column and

the name of a local folder that folder will be a logical folder in your code so your code will see just like any

regular folder if you use the inspect command you'll see The Logical folder location in DVM

instead of using a volume you can specify a local folder this is great for testing purposes let's

say you started developing your service and that you want to test on your Dev machine

if your code can read and write some files correctly you can use this kind of mapping but don't use that in production

using the inspect command you can see the local folder path and this concludes this lecture on

volumes [Music] a software system data outside of a

running container so to do that we'll use a value so I'll open a terminal

and we'll use the docker volume create and the name of the volume so this will create a volume

perfect let's Now list the volumes on my machine so there's a few here the first four

were created earlier this is the volume that we just created now let's run a ninja next image

and let's attach a or Mappy a local folder to that volume so we'll use Docker run Dash D for detach we'll name

our instance fault test with the Dash D for volume we'll use the volume name that we created earlier and map that to

a folder called ATP on our nginx image all right to that

okay excellent so that worked now let's connect to our running instance so Docker exec Dash it the name of the

instance and it will run bash here perfect let's first do an LS to see if we see

the app folder there it is so that's that folder is mapped to the volume so anything that we store or write in that

folder will be written externally outside of the container so that will persist

all right uh just for fun instead of doing a cat Let's uh install Nano inside

the running instance so I'll do first in apt-get update remember this is uh this is running

inside the the container and we'll install Nano app get the install Nano which is a small editor perfect

LCD into the app folder in open Nano so Nano and we'll create a file called text test.txt

hello volume [Music]

all right and we'll use Ctrl o to write to to disk Ctrl o enter and control X to exit Nano perfect

if I do an LS here I should see my file there it is test.txt so let's exit the running

instance and what we'll do will stop the running instance and we'll remove it from memory

stop it here and we will remove it from memory with

our m okay so now the container or the instance is gone if we would have stored

some data inside that container it would it would be lost at this point but we use a volume so the data was stored

externally so let's try to create a second instance same thing using the same volume and

let's exec to it perfect let's see what is in the app folder here is

our file so let's do cat test.txt just to prove hello volume that work

let's exit here this proved that by using a volume your data persists a container restart or

crash here the data is still there until I remove the volume so if I issue

a Docker volume removed and the name of the the volume you see doesn't work why the error says that the volume is in

news interesting so I need to stop any container instance that is that is

running and remove it from memory before deleting or removing

a volume let's try uh again term Docker volume RM for remove by volume

and this time it worked now another thing I want to show you let me create it again

perfect and let's switch to the docker UI here if I click Docker here there's a section

that list of the different volumes here so my vowel is listed here so here I can inspect I cannot look at

the files but I can I can manage it so I can click here on remove that will delete the volume

are you sure yes [Music] let's now see the yaml concepts

yaml stands for yaml ain't markup language it's a way to serialize data so that

it's readable by human beings it's the file format used by Docker compose and kubernetes

here's the sample yaml file for a key value pair you specify the key a column

data space and a value don't forget the space it's mandatory here are some nested values

you specify child values using two space indentation and quotes are not needed for string

values here's a list again the child elements are indented

with two spaces and there's a space after the dash this is what we call the block style

there's also a flow style that looks like Json so you may be tempted to use it if

you're familiar with Jason but don't I never saw any sample or any documentation using this flow Style

since it's easy to forget a space and you can spend quite some time figuring out why your yaml file doesn't

work you can use tools like this linter available on yamlin.com

it will parse your yaml and flag any errors very useful and this concludes this lecture on the

yaml concepts [Music] let's now take a look at the docker

compose Concepts let's say that your app is composed of multiple containers

you run the front-end container using a Docker run command Docker run again for the backend

container and again for the redis cache container so you end up issuing multiple Docker

run commands to run your app would it be nice if you could deploy your app using one single command

well that's the docker compost go to Define and run multi-containers application using a single yaml file

there's a compost plugin that extends the docker CLI and let you run those Docker compose files

these specifications are available here if you look at Docker compose before you may have seen that sometimes the

commands are using an iPhone so Docker Dash compose and sometimes they do not

why is this at the dockercon conference in 2022 Docker announced the general

availability of couples version 2. okay this means that there was a V1 before and the V1 command line tool was

installed separately from the docker CLI it was built using python so you needed to have python installed to run compost

V1 and the syntax was Docker Dash compose couples V2 is a drop in replacement

meaning that all the V1 commands are working as expected it's installed as the docker CLI plugin

automatically by Docker desktop to use it you type Docker space compose no hyphen needed here

it's written in go so no need to have python installed to run the command in summary it's simply a faster version

of the docker compose tool shipped as a Docker plugin instead of a python application

here's a Docker compose file there are three containers defined in it web API 1 web API 2 and API Gateway

the name that you use here defined the network or host name for that container the code running inside your container

can use these hostname to communicate between each container for each of them you specify the image

to run you set the internal and external Port the container will listen on note that the API version is now optional so

it's okay to skip it you may ask yourself should I use darker compose or not

Docker compose is perfect for small workloads that don't require a full orchestrator like kubernetes

it's perfect When developing and testing locally before deploying to kubernetes Some Cloud providers offer services that

support Docker compose like app service on Azure and ECS on AWS and of course you can simply use a

virtual machine or a VPS virtual private server with the digitalocean or linued and this concludes this lecture on the

docker compost Concepts thank you LaSalle used Docker compose

here's a cheat sheet listing some of the docker compose commands Docker composed build lets you build the

containers as defined in your Docker compose yaml file if the file is located in another folder

you can use the optional Dash F per meter and specify the files location start we'll start all the containers as

defined in your yaml file step will stop them but they'll remain in memory

up we'll do a build followed by a start this is super Endy use the Dash D parameter to run the

command in the background and take back your terminal prompt PS will list what's running

remove our RM we'll remove the containers currently from memory down we'll do a stop followed by a

remove again this is super ND logs will display the logs for a container

and you can open a session inside a container by running Docker compose exec the container name and the program to

run the docker compose file is located inside a folder and if you run Docker

compose up this will launch your application if you try to run a Docker compose up a

second time from the same folder nothing will happen because the application is currently running

if you want to run a second instance of your application it was impossible with Docker compose V1

but with V2 you can use a project name to launch a second instance of your application from the same folder

here's the cheat sheet for some of the new commands Docker compose dash dash project Dash

name followed by a project name this will run a then sense of the application as a project

the shortcut is much shorter to type Dash p instead of that Dash project Dash name

you can list the project currently running by using compose LS CP will allow you to copy files from the

containers so this is super ND to retrieve let's say log files and you can copy files to The Container

so from your machine your desktop or laptop to The Container by using Docker compose CP The Source pad the container

ID and the destination path here's an example imagine that the docker compost file is located in the

same folder where you run these commands you simply use the up command to build and run the containers and to take them

down simply use the down command and this concludes the structure on Docker compose

[Music] in this lab we will deploy a Docker compose application

let's take a look at our Docker compose.yaml file we have one section called services and

under that section we Define two Services the first one is called Web Dash Fe F4 front end it's a python

application and instead of using an image from Docker up will be building that image using the build parameter

the dot means that the docker file is at the same level as the docker compose file so here it is

it's a simple python application just one file app.pi and requirement.txt that we're copying on that base image

it will be listening on Port 5000 and this is our second service it's the redis cache and this time we'll be using

an image from Docker up all right let's open eight terminal and let's build the image using Docker

compose build perfect my image was build now I can launch the application using Docker

compose up and Dash D for detach now I could have skipped the build step because up does a build first and then a

start so it's super ND so let's use Docker couples up and my application is up and running I

can test it if I go to local OS 5000 you visited me one time and do a few refreshes five time perfect

okay I can list the running containers using Docker compose PS I can also use Docker PS since it will

list the docker container currently running and I can look at the logs for my

front-end service using Docker compose logs Dash F and the name of the service and if I

move that a little bit and it F5 a few times you see new entries are logged perfect

that works let's do a Ctrl C to terminate the log streaming

and we'll use Docker compose LS to list the currently running projects I have one project running it's called

l09-04 Docker compose well basically when I use Docker compost up I didn't specify a project name

so Docker compose use the folder name as the project name now let's try to create a second

instance of our application if we use Docker compose up Dash D again well Docker compose tell me that the

application is running so it will not start a new version we can try to deploy our second version using a project name

so Docker compose Dash p for project name we'll name it test up Dash D

let's see what will happen starting oops we have an error here hmm bind for local OS 5000 failed Port is

already allocated of course are my local old sport 5000 is in use right now so what I need to do

I need to change that Port here the localhost port I'll use 5001 save the file

and use the same command Docker compose Dash B project name test up Dash D and this time it worked awesome

let's open our browser and let's go to Port 5001 yes that worked

a few refreshes 10 times let's go back to Port 5000 the first instance 15 times

all right so let's do a Docker compose LS again to list our projects now we have two

projects the first one that we deploy without specifying a project name and the second one with the project name

test let's delete our for instance by using Docker compose down

so I didn't specify a project name Docker compose use the folder name as the project name now if I do the docker

composer list I should have only one project running yes it's test now I can delete that one using Docker compost

specifying the project name and down let's list the projects again Docker composer less

nothing running PS listening the containers nothing and why not try Docker PS

nothing in memory [Music] in this lab we will deploy a Docker

compose sample application that is composed of three services a web front-end build with react

nodejs backend and the Maria DB database let's take a look at our Docker compose file

this is a more complex than what we saw so far so let's try to break it into smaller pieces

here we have the definition of our tree services if we start from the left we have the back-end service

top right the database DB and the front end now if you look at the DB service you can see that we're

referencing an image that will pull from Docker hub and the other two Services we're using

the build parameter this means that we will build these two images

looking at the backend service we can see that we specify build and context contacts with the value of backend

backend is actually a subfolder where the docker file is located next we're defining two networks public

and private we can see that our front-end service is using the public network

the backend service is using public and private and the database service the DB service

use only the private Network front end being in the public network cannot communicate directly with the DB

service but backend being in both public and private can communicate with both DB and

front-end services we're defining also two named volumes back in dash modules and DB Dash data

and we can see highlighted in yellow that our DB service is using DB data and our backend service is using back-end

modules highlighted in yellow we also see that we're using other volumes these volumes

are scoped at the service level and are not shared between services to create an instance of our Docker

composed application we simply use Docker couples app and to bring it down Docker compose down

in Visual Studio code let's take a look at the docker compose file so it's called compose.yaml

here we have our services section Network section where we Define two networks the name volumes back-end

modules and DB data and secrets that we haven't seen yet where we're defining one key value pair so the key is DB

password and we get the secret from a file the file is located in the folder called DB and it gets the value from a

file called password.txt if we open the DB folder here's the file with the value the secret

and that will be injected when we run Docker compose up okay let's go back to the services

section and here we have our backend DB and front-end Services let's take a look at backend

we're using the build a directive and we are setting the context to backend it points to this folder called backend

here and the docker file is located inside that backend folder with the application

same thing with the front-end service build context front-end and we're getting the docker file and the

application from the front-end folder and what about the DB service well we're using an image that will pull from

Docker hub okay let's build our two images we'll open a terminal

and run Docker compose build our images were billed perfect now let's run the application by using Docker

compose up Dash D ER perfect the application is this thing on Port 3000 so let's open a browser

and type local OS 3000 is our react application it's working awesome

we can list the containers that are currently running by using Docker compose PS

we should have three backend DB front end awesome let's take a look at the logs from the

back-end service Docker compose logs Dash F backend and these are the logs for our backend

service awesome we can type Ctrl C to stop the log streaming

and we can take our application down by using Docker compose down this will stop and remove the containers

from memory do we have something else in memory we should not

perfect and even if I type doctor PS there's nothing however the volumes are still there when you do a doctor compose

down it will remove the containers from memory but will not remove the volumes so if I open the docker desktop

application and I click on volumes here I can see that I have a few well three volumes that were created a few minutes

ago so I need to delete them manually I can select them right here and click on

delete or I can do the same thing by clicking on the docker icon in vs code locating the volumes here

and delete them find it easier to do that in Docker desktop because we see when the volumes

were created so I'm pretty sure that these three are the ones that I need to delete I'll click on the delete button

and confirm thank you [Music]

let's take a look at some of the compose file features it's a good practice to set limits on

the resources that your container will use in this example I light it in yellow we

tell Docker to start the container with a quarter of a CPU and 20 megabytes of RAM

the green section is the limits that we are allowing in this case half of a CPU and 150 megabytes of RAM

to set an environment variable that will be injected in the running instance simply set the key value pair in the

environment section those values can be overridden at the common line using the dash e per meter

you can reference an environment variable using the daughter curly bracket syntax

this way you can set the variable on your machine or server and use it directly in the compose file

you can place the values in a file that you will name dot EnV located in the same folder as the compose file the

compost command will automatically read the values from that file by default all containers specify in a

compose file will see each other using their service names here we have two Services web and DB

the code running in the web service can communicate with the second one using DB as the hostname and vice versa

the web container is visible from outside of the docker network using the port number configured in the left

portion of the ports value web is listening inside the docker Network on Port 80. DB can reach web on

Port 80. finally DB only exposes one port number that's the internal port

web can reach DB using Port 5432 but DB is not visible from outside the docker Network

if you have a compose application with multiple containers you can restrict who sees who by configuring networks in this

example we're defining two Networks front end and back end proxy can see app because both are part

of the front-end Network however proxy does not cdb because it's not part of the backend Network

when using multiple containers you may want to start some of them first and wait until they are running before

starting the other ones a typical use case is a database that you want to run before sorting the main application

doing so is easy using the depends on parameter where you simply specify what is the service name that the service is

dependent on in this example app depends on DB so compost will first start DB and when DB is running compose will then

start app you can declare volumes in the volumes section

these are called named volumes and they can be used by all these services that you are declaring in the compose file

to use a volume from a service map it to a local folder using the volume name colon and the virtual path inside the

container optionally you can make the mapping read-only by appending colon Ro to the

mapping you can also create a mapping without using a named volume

this mapping can't be shared across services it's also a good practice to set a

restart policy let's say that you deploy your couple's app in a VM

and at some point you need to install some OS batches and you need to restart or reboot the server

what will happen to your compost app well if you don't specify a restart policy

the one by default is no meaning that compose will not restart the containers if they were shut down by reboot

you can set the policy to always this way compose restarts the containers until their removal

on failure resource a container if the exact code indicates an error and lastly unless stop does a restart

unless you stop or remove the containers and this concludes this look at some of the docker compose features

[Music] let's now talk about container registries

so what is the container registry it's a central repository for container images you build an image locally

then you push and store the binary the different layers 2D Repository

they can be private or public the default one is Docker hub Microsoft AWS and Google each offer

container Registries as service the benefit of using a repository from your cloud provider is that the images

are located near your app so no apps over the internet to retrieve the images so let's say we want to retrieve an

image from Docker up we issue a Docker pull command and Docker downloads the images layers and

store them in its local cache and this concludes this lecture on container registries

[Music] let's see how to push and pull images to Docker up

make sure you are logged in with your Docker user account to be sure simply type Docker login

without a username and password Docker will tell you that you're already logged in if not enter your Docker

username and password you need to tag an image with the repository name by default it's your

username if you have created some organization in Docker hub

prefix it to the name of the image in this example I want to push this image to my Kates Academy organization

then use the push command and don't forget to specify the organization name it's part of the image name

to retrieve the image we use the pull command with the image full name on Docker up public images are available

for download to anyone if you don't want to share them you need to create a private Repository

later on we will create one using our cloud provider and this concludes this lecture on

Docker up [Music] let's now push our first image to Docker

hub first thing first let's make sure that we can log in into Docker Hub so if you

head to up.docker.com make sure you can log in also if I right click here on my Docker

desktop icon I can see that I'm logged in perfect

we will containerize a node.js Express application so we'll first add the docker file

we'll use the tooling so view command palette if you can type Docker add and Docker

files to workspace this is a node.js application the package.json file is located at the

real so that's the correct one it's listening on power 3000 and we don't want Docker compose files

perfect now we need to build the image so let me open a terminal

perfect and we need to issue a Docker build command with the Dash D for tag parameter

but notice here we need to prefix the uh the name of the image with our registry name

if I select this I need to prefix that with my name here the name of my registry

let me run that the image was built successfully now I need to use the push command to push

that image onto Docker Hub again I'll select this and let's replace the registry name with

mine use your home and see what's happening here Docker is

pushing each layer to my Docker app account here all right

no errors things went fine let's go back here I'm gonna refresh this page and here it is

here's my um uh image here my Express image so I can click on this

I can edit the um the information I can see that I have my

tag is V1 right I can get more information here I can here click on public view so by

default the repositories on Docker Hub are public anyone can download and view and download your images this is the

view for someone who would look at my image so with the pull command Docker pull

let me go back here I can see the tags and so on and so on and if at some point

you want to delete this you go into the settings tab here you scroll down and you can delete that

repository here all right let's go back now let's try to pull that image to our

computer here the first thing uh I will try to do is remove it from my computer

let me type this RMI so remove image the image has gone completely so now

let's try to pull it from uh from Docker uh okay

Perfect Pull complete my image is is back here now

you see that I use the V1 tag here to to tag my image with the with the version number so let's try to build a version 2

of that image let me copy that and again let's replace this part this placeholder with my registry name

image has been built so let's now push it two Docker uh

same thing as we did before but this time we're pushing version two okay

let's go back here let's go back to my Express or the general tab look here I have V1 and V2

if I click here on tags I can see when the image was was pushed tags and people can download V1 or V2

if I want to remove my images I use the RMI command so remove image I'll remove V1

and also I remove V2 and on Docker up if I no longer need this Repository

I click here settings scroll down a little bit click on delete Repository

and I need to enter the name of my repo just to make sure and click on delete and now it's gone

[Music] time to introduce kubernetes so kubernetes or also known as Kates so

the letter K followed by the number eight so eight letters and then the number s

and it's pronounced Kate's so kubernetes is a project that was created at Google version one came in July 2015.

it was the third generation of container scheduler from Google previous projects were Borg and Omega

and Google donated the kubernetes to the cncf so now the development is supervised by the cncf

is currently the leading container orchestration tool it's designed as a Loosely coupled

collection of components for deploying managing and scaling containers it's vendor neutral so it's not attached

to a single company and it runs on all Club providers and there's a huge community ecosystem

around kubernetes so what kubernetes can do service Discovery load balancing

it can bridge to the cloud providers storage services can provide rollout rollbacks

capabilities and can monitor the health of the containers

can manage configuration and secrets and the same API is available either in a on-premising solution or in every

cloud provider so what can't kubernetes do it can deploy or build your code

and it does not provide application Level services like databases service buses caches

here's a quick look at the kubernetes architecture this diagram was taken from the

kubernetes documentation we'll take a closer look at each component but for now let's just say

that it's composed of a master node also called the control plane so that's the portion to the left

and the control plane runs the kubernetes services and controllers and you have the worker nodes these node

runs the containers that you'll deploy in the cluster so a container will run in a pod a pod

runs in a node and all the nodes form a cluster and this concludes this intro to

kubernetes [Music] let's see how you can run kubernetes

locally so do you need to install a kubernetes cluster in the cloud or ask your it

Department to install one in your Enterprise so you can test locally absolutely not there are many ways that

you can run kubernetes on a desktop or laptop Docker desktop lets you run kubernetes

macrocates from the makers of Ubuntu and minicube also let you run kubernetes altree requires that virtualization is

enabled kind runs over Docker desktop and offer extra functionalities

Docker desktop is limited to OneNote but it's usually not a problem Marco Cates kind and minicube can

emulate multiple worker nodes on Windows Docker desktop lets you run both Linux and windows containers

and you can't create and run Windows containers on Mac and Linux it runs on hyper-v or Windows subsystem

for Linux so if you have Windows 10 version 2004 or later

it's the recommended way to run Docker desktop if fiber-v is enabled on your laptop or

desktop you can't run another hypervisor at the same time and mini Cube used by default virtual

box but it can also run on hyper-v you can install Docker desktop on Windows using App review and it will

create a virtual machine named Docker desktop VM when you take the enable kubernetes

checkbox in Docker desktop it will download additional containers to run kubernetes

using Windows 10 version 2004 or later and if you have wsl2 installed you can tick the use the wsl2 base engine and

Docker desktop will create its VM inside the Linux distro you install on your Windows machine

note that this is the recommended way to run Docker desktop on Mac Docker desktop use the hyperkit