Docker and Kubernetes Fundamentals: A Beginner's Guide

TL;DR

This entry-level course builds a strong foundation in containers, Docker, Docker registries, and Kubernetes objects like pods, workloads, and services. You run everything locally on a PC or Mac using Docker Desktop with Kubernetes enabled and VS Code, so no cloud account is needed. It also covers microservices and cloud native concepts through hands-on activities.

Transcript

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 Doc... Read More

Key Insights

• Microservices architecture arranges an application as a collection of loosely coupled, fine-grained services, each with its own responsibility, communicating through lightweight protocols like an API exposed over HTTP or gRPC.
• Monolithic systems are built and deployed as a single unit, so scaling requires spinning up a new VM and copying the whole system, whereas microservices deploy and scale independently piece by piece.
• The Strangler pattern, documented by Martin Fowler, transforms a monolith into microservices by placing a facade to route calls, migrating code gradually, then removing the facade once migration is complete.
• Microservices are not magic pixie dust; they add complexity, risk domino-effect failures, and require maturity plus new processes like DevOps, CI/CD, and testing introduced step by step with metrics.
• Microservices benefits include reduced full-system failure risk since each runs in its own address space, less vendor lock-in from open source tech, and easier understanding, deployment, and scaling.
• Calls between microservices go through APIs, adding latency and transient failures, so developers should implement retry strategies in code or use a service mesh to handle intermittent errors.
• Cloud native, per the CNCF definition, uses containers, service meshes, microservices, immutable infrastructure, and declarative APIs, where immutable infrastructure means replacing components with newer versions rather than updating them.
• The course setup requires a laptop running Windows 10, macOS, or Linux with Docker Desktop (Kubernetes enabled), VS Code with the Docker extension, a Docker Hub account, and lab files from a GitHub repo.

Questions & Answers

Q: What do you need to set up your computer for this Docker and Kubernetes course?

You need a laptop, PC, or Mac running Windows 10, macOS, or Linux; Macs with Apple silicon work fine for most tools. On Windows and Mac you install Docker Desktop with Kubernetes enabled, while Linux users follow their distro's documentation. You also need Visual Studio Code with the Docker extension, a Docker Hub account, and the lab files from the course GitHub repo, which you can clone with git or download as a zip.

Q: What is a microservices architecture?

A microservices architecture is a variant of service-oriented architecture that arranges an application as a collection of loosely coupled services. Instead of one large monolithic system, you have multiple smaller pieces, each fine-grained with its own responsibility. Services communicate through lightweight protocols such as an API exposed over HTTP or gRPC. They can be written by smaller teams using different programming languages like Go, PHP, or C#, and domain-specific data can be stored in separate databases.

Q: How do microservices differ from a monolithic system?

A monolithic system is built as a single unit where multiple projects are compiled together and deployed as one, running in the same address space with tightly coupled layers. To scale it, you spin up new VMs and copy the entire system onto each. Microservices instead break the system into smaller independent parts, each deployed and scaled independently. You can scale a single service up or back without touching the rest, since functionality is exposed through APIs rather than direct references.

Q: How do you transform a monolithic system into microservices?

You break it into small units, such as extracting the code that handled identity from the business layer. Martin Fowler, author of Patterns of Enterprise Application Architecture, documented this using the Strangler pattern. You place a facade to route calls to the legacy code, migrate that code into a new microservice, and have the facade route calls to it. Over time the legacy system shrinks until migration is complete, at which point you remove the facade.

Q: What are the drawbacks and anti-patterns of microservices?

Microservices are not magic that fixes an existing system instantly; they require effort and maturity. Splitting a monolith into many pieces adds complexity, and a change to one microservice can cause a domino effect that takes the system down. Securing many services is harder, testing must cover the whole system, and API calls add latency plus transient failures needing retry strategies. Instead of one point of failure you get many, so start small and add metrics to validate each step.

Q: What are the benefits of using microservices?

Since each microservice runs in its own address space, there is less chance that one failing service takes down the whole system. Microservices run on open source technologies, reducing vendor lock-in. Because they are smaller, they are easier to understand in most cases, faster to deploy, and easier to scale. You can also scale an individual service back when needed. These advantages make systems more flexible compared to large tightly coupled monolithic applications.

Q: What is cloud native and how does the CNCF define it?

Cloud native is a way to architect and build complex systems that takes advantage of modern development practices and cloud infrastructure. According to the Cloud Native Computing Foundation, it uses containers, service meshes, microservices, immutable infrastructure, and declarative APIs. Immutable infrastructure means you generally replace a component with a newer version rather than updating it. Cloud native systems are loosely coupled, observable through metrics, automated in creation and updates, and deploy small impactful changes frequently using open source projects.

Q: What topics and outcomes does this Kubernetes course cover?

The course covers containers, Docker, and the Docker registry, plus Kubernetes objects like pods, workloads, and services. It also teaches microservices and cloud native concepts, including containers, service meshes, and immutability. It is an entry-level course, so you will not become an expert, but you gain a strong foundation and enough knowledge to make sound decisions at work or in projects. It includes many hands-on activities, and everything runs locally on your own PC or Mac.

Summary & Key Takeaways

• Guy Barrette, a Montreal-based full-time trainer and Microsoft MVP certified on Kubernetes, Terraform, and major clouds, hosts this entry-level course. It provides a strong containers and Kubernetes foundation with many hands-on activities, requiring no prior Docker or Kubernetes knowledge and no cloud provider account.

• The course explains microservices as loosely coupled, independently deployable services replacing tightly coupled monoliths. It covers converting monoliths using the Strangler pattern, anti-patterns warning that microservices add complexity, and benefits and drawbacks like reduced failure risk versus added latency and security concerns across many services.

• Cloud native is defined as architecting complex systems using containers, service meshes, microservices, immutable infrastructure, and declarative APIs, emphasizing speed and agility. Learners run Docker Desktop with Kubernetes enabled locally alongside VS Code and the Docker extension, downloading lab files from GitHub to practice.