Kubernetes from Basic to Advanced

Course description

Overview

Docker is an open platform for building, deploying, and running applications in containers. Kubernetes goes a step further—it provides the mechanisms required to automate deployments, scaling, and management of containerized applications in a cluster, taking into account networking, security, observability, and high availability.

During the course, participants will go through a complete, practical scenario: from running a container and working with Docker images, through building core Kubernetes objects (pods, volumes, deployments, services), to more advanced topics—namespaces and environment separation, security (authentication and authorization), networking (CNI), monitoring and logging, scaling, upgrades, and troubleshooting common issues.

The course is hands-on in nature: each topic is reinforced with exercises that reflect real-world situations encountered by DevOps, SRE, and container platform administrators.

Outcomes after the course

You will configure and run a Docker container and consciously select images for server and database use cases.
You will deploy containerized servers and databases and learn common pitfalls (volumes, data persistence, parametrization).
You will install a Kubernetes cluster and understand its architecture and the role of individual API objects.
You will use Kubernetes to deploy and manage multiple environments within the same cluster (namespaces, isolation practices).
You will apply basic security mechanisms (authentication and authorization) as well as good risk-minimization practices.
You will design networking and service exposure (including non-HTTP) and understand the differences between Docker and Kubernetes networking.
You will configure cluster monitoring and logging (incl. Prometheus, cAdvisor, Elasticsearch + fluentd) and build basic observability.
You will perform scaling and application updates with minimal user impact and practice troubleshooting.

Book the course

Format: Remote
Language: Polish
Type: Public course, guaranteed
Date: 12–13.03.2026
Duration: 2 days (7h/day)
Delivery mode: Lecture + discussion + intensive hands-on exercises

BOOK – 2450 PLN

Net price per participant.

Who this course is for

System administrators and infrastructure engineers who deploy or maintain containerized applications.
DevOps / SRE professionals responsible for CI/CD, reliability, automation, and environment scaling.
Developers and technical leaders who want to better understand Kubernetes deployments and cooperation with platform teams.
People preparing for a Platform Engineer role or working with microservices.

Prerequisites

Basic knowledge of Linux systems (navigation, file editing, permissions).
Basic networking concepts (TCP/IP, DNS, ports, firewall – at a general level).
Nice to have: basic command-line experience and understanding of the concepts of image, container, and repository.
Lab environment: a computer with internet access and a toolset as instructed by the trainer (e.g. Docker, kubectl, cluster environment).

Methodology and way of working

Short introductory lecture + discussion (shared “why” and “what for”).
Hands-on exercises carried out step by step with the instructor (labs).
Mini operational scenarios: deployment, service exposure, scaling, updating, problem diagnosis.
Production best practices: checklists, common mistakes, and recommended patterns.

Technical notes

During the course, various Docker images may be used as example daemons (e.g. Nginx, MongoDB, Tomcat). If the organization wants to work through a specific stack (e.g. custom images, a specific database, a specific CNI), we can plan customization as part of a dedicated course.

What the participant takes away from the course

Practical ability to work with Docker and Kubernetes in deployment and operations scenarios.
A set of recommendations and best practices applicable in the organization’s environment (naming, isolation, monitoring, security).
Exercise materials and sample manifests (as agreed with the trainer).

Customization and consultations

If you want the workshop to be embedded in your environment (specific images, CI/CD tools, security policies, CNI, cloud), we can prepare a short needs assessment before the course and tailor the exercises to real-world use cases.

Course agenda

Introduction

Course objectives and workshop rules.
Containerization vs. virtualization – where we truly gain value and where complexity increases.

Overview of container orchestration with Kubernetes

Why orchestration is needed at scale.
Key use cases: microservices, multi-team environments, variable traffic.

Overview of Kubernetes architecture

Pod, labels/selectors, replication controllers, services, API.
Controller, scheduler, etcd – the role of control plane components (operational context).

Installing a Kubernetes cluster

Installation options and environments: local, cloud, on-prem.
Verifying cluster health and basic administrative commands.

Pulling a Docker image from the internet

Registries, tags, digest – how to control versions and risk.
Image scanning and hygiene (introduction to best practices).

Creating pods, volumes, and deployments in Kubernetes

Pods and containers: specification, resources, restart policies.
Volumes and data persistence: where mistakes are most often made.
Deployments and the basics of deployment strategies.

Grouping and organizing the cluster

Labeling, selectors, resource organization – order that scales with the team.
Basics of policies and naming standards.

Using Kubernetes namespaces to manage different environments

Managing test, staging, and production environments in the same cluster.
Best practices for using namespaces (isolation, order, limiting the blast radius of errors).

Finding and connecting to containers

Diagnostics: exec, logs, describe – the quick “first 10 minutes” in an incident.
Most common pitfalls: permissions, namespaces, networking.

Discovering and exposing services

Service, endpoints, ingress – how users reach the application.
Non-HTTP services (Passive FTP, SMTP, LDAP, etc.) – when and how to expose them.

Kubernetes security

Authorization and authentication – practical fundamentals.
Least privilege and typical configuration risks.

Upgrading a Kubernetes cluster

Minimizing impact – planning maintenance windows and upgrade strategies.
Controlling component compatibility.

Advanced networking

Docker networking vs. Kubernetes networking – differences that matter.
Basics of network debugging in the cluster.

Interfacing between network providers and Kubernetes networking

Best practices for segregating services in the cluster.
Comparison of CNI providers (performance, features) – selection criteria.

Kubernetes monitoring

Cluster logging: Elasticsearch and fluentd (introduction).
Container monitoring: cAdvisor UI, InfluxDB, Prometheus – what we measure and why.

Best practices for running containerized servers and databases

Data persistence, backup, versioning, and parametrization.
Anti-patterns: what not to do in production.

Scaling a Kubernetes cluster

When to scale horizontally and when to scale vertically.
Cost and operational dependencies (informed decisions).

Infrastructure for Kubernetes

Deployment, segmentation, networking – foundations for a stable cluster.
Infrastructure dependencies that usually surface “too late”.

Building a high-availability cluster

Load balancing and service discovery.
HA critical points – how to identify them and reduce risk.

Deploying a scalable application

Automatic horizontal pod autoscaling.
Database clustering in Kubernetes – basic approaches and limitations.

Updating the application

Versions in Kubernetes – rollout/rollback strategies and minimizing downtime.

Troubleshooting

Diagnosing and fixing common Kubernetes issues.
Practical checklist: symptom -> hypothesis -> verification -> action.

Summary and takeaways

Review of key concepts and best practices.
Recommendations for further development: a learning path of tools and topics to deepen.

People flying on paper airplanes to a course.

No Budget? Get Funding!

A program that allows you to easily and quickly obtain funds for individual training participants.

Learn more

Offer of public courses with guaranteed dates shown as pictograms in screws.

Why a Guaranteed Course?

Guaranteed implementation – the course takes place regardless of the number of participants.
Knowledge exchange and networking with professionals from various industries.
Interactive, live sessions – not just theory, but also practical exercises and discussions.
Flexible online format – join from anywhere.