LabHub — 실습으로 배우는 IT

읽고 끝나지 않습니다. 브라우저의 실제 서버에서 실습합니다.

IT Foundations

Whether you studied computer science or not, the place you get stuck at work is usually where a foundation has a hole in it. This path walks computer architecture, operating systems, networking, and databases in turn and fills those holes. By the end you can narrow an incident down to which layer and which problem on your own.

Computer Architecture — What it takes for a CPU to execute one line
Operating Systems — How many people share one machine
Networking Fundamentals — Where to look first when a connection fails
Database Concepts — Tables, indexes, transactions — on a real PostgreSQL

Linux & Terminal Mastery

Builds the ability to narrow a problem all the way down on a server where only the terminal is left. You start with files, permissions and processes, then work by hand through shell scripting, vim and tmux, disk, memory, file-descriptor and load incidents, and name resolution and socket diagnosis. By the end you can explain in a few commands why df shows free space you cannot use, and why load is 24 while the CPU sits idle.

Linux Fundamentals — It is fine if this is your first terminal.
Shell Scripting — Not a throwaway script — one you would put on a server.
vim and tmux — Without a mouse you actually get faster.
Linux Incident Response — df shows free space, so why can you not write.
Linux Network Diagnosis — Is the name not resolving, the connection not opening, or the server just slow.

Container Mastery

Five courses that climb from running your first container to namespaces and cgroups, the OCI image format, and least-privilege images. Instead of memorising commands, you narrow a cause from a single exit code, point at the one line that broke the cache, and prove with inspect what got baked into an image. By the end you can review someone else's Dockerfile in three minutes.

Docker Fundamentals — A first course for people running their first container.
Building Images — Slow builds are usually about ordering, not caching.
Volumes, Networks and Compose — One container does not make a service.
Container Internals — There is no such thing as a container in the kernel.
Container Security — Start by breaking the belief that isolation makes it safe.

Kubestronaut — Five Kubernetes Certifications

CNCF Kubestronaut is the title you earn by holding all five of KCNA, KCSA, CKA, CKAD and CKS. This path starts at concepts (KCNA) and works by hand through operations (CKA), development (CKAD), security fundamentals (KCSA) and security practice (CKS) on a real cluster. By the end you can look at a manifest and say what is wrong with it in three minutes.

KCNA — Kubernetes and Cloud Native Associate — Pin down the vocabulary, then open a cluster by hand
CKA — Kubernetes Administrator — Build the hands that repair a cluster.
CKAD — Kubernetes Application Developer — Write manifests by hand and get graded on the spot
KCSA — Kubernetes Security Associate — Look at the cluster again through an attacker's eyes
CKS — Kubernetes Security Specialist — Build the hands that actually lock a cluster down.

Golden Kubestronaut

Continue beyond Kubestronaut with observability (PCA, OTCA), networking (ICA, CCA), delivery (CAPA, CGOA), policy (KCA), platforms (CNPA, CBA, CNPE) and Linux (LFCS). Prepare through readings, quizzes and exercises; completing a course does not award official certification or guarantee an exam pass. Initial Golden Kubestronaut recognition requires valid certifications designated by CNCF and LFCS. Check the official list and effective dates when planning your exams.

PCA — Prometheus Certified Associate — From the questions metrics answer to real PromQL judgement
OTCA — OpenTelemetry Certified Associate — The four places propagation breaks, and the collector pipeline
ICA — Istio Certified Associate — A VirtualService on its own does nothing.
CCA — Cilium Certified Associate — Delete iptables and put policy in the kernel.
CAPA — Argo Project Associate — Assemble all four Argo projects by hand.
CGOA — GitOps Certified Associate — If Git is the truth, the cluster follows
KCA — Kyverno Certified Associate — Write policy that does not stop the cluster.
CNPA — Cloud Native Platform Engineering Associate — How to build a platform like a product
CBA — Backstage Associate — How many services do we have, and who owns them
LFCS — Linux Foundation System Administrator — Prove by hand the Linux underneath Kubernetes
CNPE — Cloud Native Platform Engineer — The judgement to design a platform and to defend it

SRE / DevOps Engineer

Six courses — pipelines, GitLab CI, IaC, observability, Git, and load testing — on the craft that makes deployment routine rather than an event. You handle mechanisms rather than tool names: why a gate must speak in exit codes, what the three symbols in a plan mean, where the burn rate 14.4 comes from. By the end you can look at an alert that fired at 3am and decide what to do now.

CI/CD Pipelines — Build the mechanics of a pipeline in shell, without Jenkins
GitLab CI/CD — Face the configuration language and execution model head-on, with no runner
Infrastructure as Code — Declarative, idempotent, stateful — the principles before the tool
Observability — Run PromQL, SLOs and alerts on a real Prometheus
Git in Practice — Stop being afraid of undo and rebase
Load Testing — Training to look at the tail instead of the average

FDE — Forward Deployed Engineer

A path for practising the Forward Deployed Engineer role that Palantir created and that OpenAI and Anthropic now compete to hire. You scout a customer system with no documentation and no dashboard, debug code somebody else wrote, clean dirty customer data, reconstruct an incident timeline from logs alone, integrate an API, and finally turn all of it into a report a non-engineer will read. By the end, the first thirty minutes in an unfamiliar environment are already decided.

In Front of an Unfamiliar System — How to start when you know nothing at all.
Debugging in Practice — Fix code someone else wrote and left, working from symptoms alone.
Working With Customer Data — Real customer data does not look like sample data.
Finding the Cause in Logs — With no dashboard, logs are your only eyes.
Integration and Deployment — Connect it, defend it, explain it.
Irreversible Changes — The day hands that only ever read finally write.
The Language of Banking — Finding the cause is not enough if you cannot speak the domain.
Insurance Domain Deep Dive — In week one at an insurer, what blocks you is the vocabulary, not the technology.
Air-Gapped Sites — Defence and Government — How to work where you cannot search, install, or take anything out.
Capital Markets and Settlement — Where milliseconds become incidents and ordering becomes money.
FDE Capstone: The Warehouse Got the Same Order Three Times — From a customer's CSV to deduplicated reservations and handoff

Data & AI Engineering

Start with the hands-on work of SQL, design pipelines that stay safe when they fail, and build the internal parts of an LLM application yourself. By the end, when someone reports that the data looks wrong, you can narrow down with numbers which stage went astray.

SQL in Practice — From SELECT to the execution plan, all run by hand
Data Pipelines — Fail, rerun, and the result must be the same
Apache Spark — The answer to a slow job is in the plan and the event log — Measure shuffles, joins and skew in local-mode Spark with the event log
Apache Hadoop — Stand up and run HDFS and YARN in one pod — Blocks, permissions, quotas and MapReduce by hand on pseudo-distributed HDFS and YARN
Apache Flink — Running Streams on a Real Engine — Verify watermarks, state and checkpoints from the engine's own output
ClickHouse — A Columnar Analytics Database from the Inside — Read sort keys, parts and merges through the numbers in system tables
LLM Engineering — From the tokeniser to RAG evaluation, from the ground up
AI Agents — A Graph, Not a Model — Stop conditions, failure paths, traces. Where a demo and a product part ways
Transformers — Compute Attention By Hand — Confirm with numbers why you divide by √d
The AI Diet Gone Wrong — Build a real INT8 model and measure accuracy and performance
Last Week Had a Better Model. Nobody Can Find It — Build the run ledger, registry and promotion gate by hand
The agent dropped my database — Write an MCP server with the standard library and guard it three ways

DevOps in Practice

Deploying and rolling back with Helm; reading CPU and memory when you have been paged at 3am. Instead of memorising tool names, you do it by hand on a real cluster and a real /proc.

Helm Deployment and Rollback Scenarios — It is only a deployment if you can undo it — on a real cluster
Diagnosing CPU and Memory Leaks — What to check before you trust the numbers in top
SLOs — Deciding How Much Breakage Is Allowed — 99.9% is 43 minutes a month
The Build Was Green — So Who Put That Library In? — Prove an artifact with its inventory, signature and provenance

Advanced Networking

From fundamentals like addresses and gateways, through the hairpin NAT you will certainly hit when you open a server at home, to Envoy — the thing a service mesh actually is — and Istio above it.

Addresses, Subnets and Gateways — Why classes A, B and C disappeared, and what replaced them
Network Fundamentals — Hands-on in a Linux VM — Touch ARP, routing, DNS, TCP, firewalls and NAT with netns and tcpdump
Kubernetes Networking — On a Real Cluster — Count for yourself how a name resolves and what a policy blocks
Envoy Internals — In the end this proxy is what handles a service mesh's traffic
Istio Deep Dive — Why It Flows That Way — A VirtualService on its own does nothing
The certificate was renewed, but the browser still showed the old one — Reproduce DNS caching and TLS certificates by hand inside a pod

System Administrator

Work by hand through what happens in front of a server every day. Install packages, narrow down layer by layer why a name will not resolve, connect with a key and move files, write one fstab line exactly right, handle qcow2 images and rootless containers, bring GPU drivers into an air-gapped network, and finish a backup with a restore rehearsal. At the end you write a Slurm configuration to spec and find the cause in a broken one.

Package Management — What happens behind one install command.
Network Troubleshooting — Break a report of "it doesn't work" into layers.
SSH and File Transfer — Connect with a key, move files safely, dig a tunnel.
Storage and Mounts — One fstab line saves or kills your boot.
Virtualisation with QEMU/KVM — A qcow2 backing chain is what makes a golden image.
Running Rootless Podman — No daemon, no root, still containers.
Air-Gapped GPU Driver Installation — A transfer procedure you finish in one USB trip.
Backup and Restore — Without a restore rehearsal it is not a backup.
HPC and Slurm — How several people share eight GPUs.
RHEL-Family Administration — dnf, rpm, createrepo — and unit files.

Advanced Observability & Logging

What to attach as a sidecar, where to cut your logs, where a trace breaks, and which question separates Loki from OpenSearch. Design judgement rather than tool usage.

Sidecars and Multi-Container Patterns — Why you would put two containers in one pod
Designing a Log Pipeline — Collecting is easy; finding it later is not
Where Distributed Tracing Breaks — The sidecar makes spans and the chain still breaks
Loki — A Log Store That Does Not Index Logs — The decision to index only labels changes everything
Grafana Dashboards — Adding graphs and getting answers pull in opposite directions
Cron Ran curl at Three in the Morning — Write detection rules, then run the response playbook

Platform Engineering

Move away from SSHing into a server and typing commands, and learn to declare the state you want in code and let the tooling converge on it. You work by hand through ten courses: Ansible and OpenTofu, Kubernetes operations, Helm, CRDs and operators, Istio, GitOps, and policy engines. By the end you can turn an infrastructure change into reviewable work that records who changed what, when, and why.

Ansible Fundamentals — Stop SSHing into servers by hand.
Ansible in Practice — Fold your copy-pasted playbooks into roles.
Terraform/OpenTofu Fundamentals — Declare it, manage it as state, read the plan.
Terraform in Practice — Handle modules, state and drift by hand.
Kubernetes Operations — Only the things that page you at 3am.
Kubernetes Distributions — Build Them Yourself — Stand up k3s and k0s, then restore etcd
Authoring and Shipping Helm Charts — Write a chart yourself and roll back by revision.
CRDs and Operators — Add your own type to the Kubernetes API.
Istio Service Mesh — Take traffic and security out of your code.
GitOps and Argo CD — Finish a deployment with one commit.
Policy as Code — Carve the rules into the cluster, not into a document.
GPU Operator and Time-Slicing — Starts from the incident that made four GPUs unusable at once.

Korean SI in Practice

Covers, in order, what a new hire meets in the first week on a Korean SI/SM project. You start with deliverables like requirement specifications and cutover checklists, then work by hand on real servers through Tomcat and nginx operations, LDAP and SSO integration, system-to-system interfaces, and database migration. The bar is the things school does not teach but the job asks for on day one.

The SI Project Process — One full lap, from requirements to go-live and stabilisation
Tomcat & nginx Operations — Every setting you actually touch in front of and behind a WAS
nginx Incident Response — Cause the outage yourself, then name the culprit from the logs
Enterprise Authentication Integration — LDAP, SSO and DRM — the things already at the customer site
System Integration (EAI) — From the interface specification to reprocessing design
SI Database Operations — Standards, change control, tuning and migration — by hand
Spring Boot — Count How Many Queries Go Out — Why @Autowired does not belong on a field
The heap had room, but the service stopped — Read JVM stalls with GC logs, thread dumps, pool exhaustion and heap dumps

Cloud-Native Architecture

Build by hand the pieces you need the moment you split one service in two. Six courses: service-to-service communication and resilience, queues and asynchronous APIs, Redis caching and live leaderboards, S3 and SeaweedFS, Keycloak-based enterprise authentication, and LLM serving. By the end you can argue in an architecture review in terms of what you pay and what you get.

Microservice Architecture — How not to split, before how to split.
Queues and Asynchronous APIs — Slow work, later and safely.
Redis and Caching — Leaderboards with ZSet; caches, carefully.
Object Storage and S3 — Thinking in objects rather than files.
Keycloak and Enterprise Identity — The protocol behind one login button.
LLM Serving — Learn the machinery of serving without a model.
The order arrived twice, and once it vanished — Reproduce and stop duplicates and loss on a single-node KRaft broker
There Were Two Leaders — Feel terms, quorum and partitions with your own hands

Database Operations

Writing good queries and operating a database are different jobs. You stand up replication, actually promote a replica, and watch the timeline diverge with your own eyes. Then you diagnose a database that is still up but has gone wrong.

PostgreSQL Replication and Promotion — Stand up a standby, then actually promote it
Backup — Bring Deleted Data Back — A backup you have never restored is not a backup
Schema Changes That Do Not Stop the Service — One migration line can queue up every request
PostgreSQL Incident Response — Diagnose a database that is up but behaving strangely
MongoDB — The Judgement Behind Document Databases — Not query syntax, but how far to embed

Application Development

Backend frameworks, languages, and tests. Not how to use them, but how each one bends the shape of your code.

Testing Tools in Practice — What 100% coverage does not guarantee
Building Servers in Go — Having no exceptions changes the shape of your code
Rust — What the Compiler Refuses — Use a borrowed value twice and the build says no
FastAPI — Types Are the Contract — One misplaced async def stalls the whole server
I searched for a whale, but got a cat — Fix React search races and build a view for 10,000 results
It failed, but the exit code was 0 — From Python script to ops tool — exit codes, retries, metrics, tests

Cloud Foundations

Plenty of curricula go deep on Kubernetes and Linux while leaving the cloud underneath blank. This path fills that gap. You start with regions and the shared responsibility model, read IAM policy documents yourself, split CIDR blocks by hand, and finish by comparing two architectures through their pricing models. Because it deals in the reasons behind a decision rather than where the console buttons are, it sticks whether you learn on AWS or Azure. By the end you can argue in an architecture review in terms of what you pay and what you get.

Cloud Fundamentals — Regions, shared responsibility, managed services — where the bill starts making sense.
Cloud Permission Design — Learn least privilege in your hands by writing policy documents yourself.
Cloud Network Design — Split CIDR by hand and narrow "it doesn't work" down by layer.
Cost and Architectural Decisions — Read the bill, then argue your design with those numbers.

Backend Engineering

Against a real PostgreSQL and a real HTTP boundary, you connect data integrity, idempotency, resource authorization, observability, deployment, and incident review into one backend system you can verify.

Production Backend API Capstone — From PostgreSQL and real HTTP to operational evidence, proven as one system
Concurrency — When Two People Touch One Row — Stock goes negative because of ordering, not code
Idempotency — Two Clicks, One Charge — You cannot stop the retry. You can only stop the duplicate
I renumbered a field and the old client silently read the wrong value — Verify protobuf bytes and schema-evolution rules by hand

3D Graphics and Physics Engines

Build by hand the computations that run behind a single triangle reaching the screen, and behind a stack of boxes standing without collapsing. This is not about how to use an engine but about what happens inside one. You use only standard Python with no libraries, and every lab leaves its result as a PNG you can check with your own eyes in the web preview.

3D Math and a Software Rasterizer — Build by hand every computation behind a single triangle reaching the screen.
The Skeleton of a Physics Engine — Build integrators, collision detection, impulses and constraints yourself, then stack boxes.
Shaders and the GPU Pipeline — Learn what the GPU computes by imitating vertex and fragment shaders on the CPU.

Backend Interview Prep

Read one real job posting sentence by sentence to decide what to do first, then stand up the missing parts of a Node.js backend yourself using only the standard library. Instead of memorising a framework, you build the eye that reads one.

A Backend Roadmap Read From Job Postings — Decide what to do first, then start
Node.js Backend — What the Framework Hides — Build what Nest does without installing Nest
It Wasn't One Request - Everything Got Slow — One request blocks the loop; every request pays

Electronics and Board Validation

Model voltage, current, loading and ADC inputs, while distinguishing simulations from physical board measurements.

Electronics Foundations — Validating Sensor Inputs — Why a voltage divider changes when you connect a load
The Fridge Insists It Is 255°C — Debug signs, partial reads, retries, and deadlines in C
My Cable Has an Echo — Use ngspice and Python to verify propagation, reflections and termination
The Sensor Is Fine. The Board Cannot Understand It — Decode captured waveforms yourself to find the fault

Sockets and Real-Time Systems

Implement byte boundaries and connection lifecycles, reproduce failures, and learn the foundations of real-time applications.

My TCP Parcel Arrived in Pieces — Reconstruct messages from fragments of bytes
One Slow Subscriber Froze the Livestream — Isolate one stalled subscriber and keep the rest moving
The snack machine died before ACK — Reconnect without counting stock twice
One Slow Connection Froze Every Other One — Watch hundreds of connections from one loop

Advanced Frontend

Why state libraries insist on immutability, how streaming actually breaks, how the browser reads HTML, how the cascade is computed. Not above the API surface — beneath it.

HTML — One Tag Stands In For a Feature — Why a button made from a div is not a button
CSS — The Later Rule Wins — The real reason you end up reaching for !important
State Management — Build the Library Yourself — Why every one of them insists on immutability
SSE — How the Server Speaks First — It works, so why does it all appear at once
SSR — The Server Draws First — When the server and the client produce different HTML

Systems Detective

Reproduce failures in an isolated lab and narrow down their causes. Compare status indicators with real requests to practice debugging and operations.

Break Kubernetes — My YAML Did It — Find the failure hiding behind green status
I Break It — A Chaos Lab Where the Hypothesis Comes First — Write down what will happen before you break it
The Logs Came From the Future — Five Incidents a Clock Made — A timestamp is a claim, not evidence

전체 코스 목록 보기