Docker dla początkujących - pierwsze kroki

Czym jest Docker i dlaczego wszyscy o nim mówią?

Docker to platforma do konteneryzacji aplikacji. Kontener to lekkie, izolowane środowisko, które zawiera aplikację i WSZYSTKIE jej zależności - system operacyjny, biblioteki, runtime, konfigurację. Dzięki temu aplikacja działa identycznie na Twoim laptopie, serwerze testowym i produkcji.

Słynne "u mnie działa" przestaje istnieć. Jeśli kontener działa na Twoim komputerze - zadziała wszędzie.

Docker to must-have w CV Cloud Engineera. W 2026 praktycznie każda oferta pracy DevOps/Cloud wymaga znajomości Dockera. Z mojego doświadczenia - nie wyobrażam sobie dnia pracy bez Dockera. Używam go do lokalnego developmentu, testowania infrastruktury i pakowania aplikacji na AWS. W tym artykule nauczysz się podstaw - od instalacji po stworzenie własnego kontenera.

Kontener vs maszyna wirtualna

Kontenery są często porównywane do VM (Virtual Machines), ale to fundamentalnie różne technologie:

Kontener to nie "lżejsza VM". Kontener to izolowany proces, który współdzieli kernel z hostem. Dlatego jest tak szybki i lekki.

Podstawowe pojęcia

• Image (obraz) - szablon/przepis na kontener. Zawiera OS, biblioteki, aplikację. Immutable (nie zmienia się)
• Container (kontener) - uruchomiona instancja image. Można go startować, stopować, usuwać
• Dockerfile - plik tekstowy z instrukcjami budowy image. Przepis krok po kroku
• Docker Hub - publiczne repozytorium gotowych obrazów (nginx, python, node, postgres)
• Registry - miejsce przechowywania obrazów (Docker Hub, AWS ECR, GitHub Container Registry)
• Volume - trwały storage dla danych kontenera (dane przeżywają restart)

Instalacja Docker

# Linux (Ubuntu/Debian)
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER
# Wyloguj się i zaloguj ponownie

# Sprawdź instalację
docker --version
docker run hello-world

Na Windows/Mac - zainstaluj Docker Desktop z oficjalnej strony Docker.

Pierwszy kontener - od zera do działającej aplikacji

# Uruchom serwer Nginx
docker run -d -p 80:80 nginx

# Co się stało:
# 1. Docker pobrał obraz "nginx" z Docker Hub
# 2. Stworzył kontener z tego obrazu
# 3. Uruchomił go w tle (-d = detached)
# 4. Zmapował port 80 kontenera na port 80 hosta (-p 80:80)

Otwórz przeglądarkę na http://localhost - widzisz stronę Nginx! Jeden command i masz serwer web.

Podstawowe komendy Docker

# Lista działających kontenerów
docker ps

# Lista WSZYSTKICH kontenerów (włącznie z zatrzymanymi)
docker ps -a

# Zatrzymanie kontenera
docker stop CONTAINER_ID

# Usunięcie kontenera
docker rm CONTAINER_ID

# Lista pobranych obrazów
docker images

# Usunięcie obrazu
docker rmi IMAGE_ID

# Logi kontenera
docker logs CONTAINER_ID

# Wejście do kontenera (interaktywny shell)
docker exec -it CONTAINER_ID /bin/bash

Dockerfile - budowanie własnego obrazu

Dockerfile to przepis na obraz Docker. Przykład dla prostej aplikacji Python:

# Dockerfile
FROM python:3.12-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8000

CMD ["python", "app.py"]

Każda linia Dockerfile to warstwa (layer). Docker cache'uje warstwy - jeśli `requirements.txt` się nie zmienił, Docker nie instaluje ponownie zależności. Dlatego kopiujemy requirements PRZED kodem aplikacji.

Budowanie i uruchamianie

# Budowanie obrazu
docker build -t my-app:1.0 .

# Uruchomienie
docker run -d -p 8000:8000 my-app:1.0

# Tagowanie i push do registry
docker tag my-app:1.0 123456789012.dkr.ecr.eu-central-1.amazonaws.com/my-app:1.0
docker push 123456789012.dkr.ecr.eu-central-1.amazonaws.com/my-app:1.0

Docker Compose - multi-container applications

Realne aplikacje to więcej niż jeden kontener. Docker Compose pozwala zdefiniować całe środowisko w jednym pliku:

# docker-compose.yml
services:
  web:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/mydb
    depends_on:
      - db
      - redis

  db:
    image: postgres:16
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: mydb
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  postgres_data:

# Uruchomienie całego stacku
docker compose up -d

# Zatrzymanie
docker compose down

# Przebudowanie po zmianach kodu
docker compose up -d --build

Jedno polecenie i masz aplikację webową + bazę danych + Redis. Idealny workflow do developmentu. W projektach, które prowadziłem, Docker Compose to pierwszy plik, który tworzymy - dzięki niemu każdy nowy developer w zespole ma działające środowisko w 5 minut.

Best practices Dockerfile

# Multi-stage build example (Go)
FROM golang:1.26 AS builder
WORKDIR /app
COPY . .
RUN CGO_ENABLED=0 go build -o server .

FROM alpine:3.22
RUN adduser -D -u 10001 nonroot
COPY --from=builder /app/server /server
USER nonroot
CMD ["/server"]
# Obraz końcowy: ~15 MB zamiast ~1 GB

Docker na AWS

Docker to fundament konteneryzacji na AWS. Oto główne usługi:

Typowy flow: budujesz obraz Docker -> pushjesz do ECR -> uruchamiasz na ECS Fargate lub EKS.

# Push image do AWS ECR
# Jednorazowo: utwórz repozytorium
aws ecr create-repository --repository-name my-app --region eu-central-1

aws ecr get-login-password --region eu-central-1 | \
  docker login --username AWS --password-stdin 123456789012.dkr.ecr.eu-central-1.amazonaws.com

docker build -t my-app .
docker tag my-app:latest 123456789012.dkr.ecr.eu-central-1.amazonaws.com/my-app:latest
docker push 123456789012.dkr.ecr.eu-central-1.amazonaws.com/my-app:latest

Docker w codziennej pracy Cloud Engineera

Docker to nie tylko "uruchamianie aplikacji". Jako Cloud Engineer używasz go do:

• Local development - docker compose daje każdemu w zespole identyczne środowisko
• CI/CD - budowanie i testowanie w kontenerach (GitHub Actions, CodeBuild)
• Packaging - pakowanie aplikacji do deploymentu na AWS (ECS, EKS)
• Narzędzia - uruchamianie narzędzi DevOps w kontenerach (terraform, aws-cli, ansible)
• Testowanie - testcontainers do integration testów z prawdziwą bazą/Redis

Najczęstsze błędy początkujących

Następny krok

Podstawy Linuxa przydadzą Ci się przy pracy z kontenerami - sprawdź 20 komend Linux dla Cloud Engineera.

Docker to pierwszy krok. Następny to Kubernetes (orchestracja kontenerów w skali) i usługi AWS (ECS, EKS, Fargate). Jeśli chcesz zobaczyć, jak Docker wpisuje się w szerszą ścieżkę kariery - przeczytaj Jak zostać Cloud Engineerem - roadmapa 2026. A jeśli interesuje Cię automatyzacja infrastruktury, w której Docker odgrywa kluczową rolę, sprawdź Terraform - Infrastructure as Code od podstaw.

Zacznij od praktyki - skonteneryzuj swój projekt i wdróż go na AWS. To najlepszy sposób na naukę.