🐳 Docker

Multilingual DevOps cheat sheet: Linux, Docker, Git, Kubernetes, Helm, Terraform, practical scenarios & templates.

Docker to platforma do uruchamiania aplikacji w odizolowanych kontenerach. Ta ściągawka zawiera polecenia do pracy z obrazami, kontenerami, sieciami, wolumenami, a także Docker Compose i Swarm.

📦 Podstawowe polecenia

Polecenie	Przykład	Opis
docker		Główne polecenie CLI Dockera używane do uruchamiania podpoleceń i zarządzania kontenerami, obrazami, sieciami i wolumenami
docker version		Wyświetl zainstalowaną wersję Dockera (klient i serwer). Przydatne do weryfikacji instalacji
	docker version --format '{{.Client.APIVersion}}'	Pokaż tylko wersję API klienta Dockera
	docker version --format '{{.Server.Version}}'	Pokaż tylko wersję serwera Dockera (Engine)
	docker version --format '{{json .}}'	Wyświetl pełną informację o wersji w formacie JSON
docker system info		Wyświetl ogólne informacje o systemie Docker: liczba kontenerów, obrazów, zasobów
	docker info	Pokaż dane Dockera: wersje, sieci, liczbę kontenerów i obrazów
	docker info --format '{{json .}}'	Wyjście w formacie JSON — przydatne do automatyzacji
	docker info --format '{{.NCPU}} CPUs, {{.MemTotal}} bytes RAM'	Pokaż liczbę CPU i całkowitą pamięć
	docker info --format '{{.Driver}}'	Pokaż sterownik przechowywania używany przez Dockera
docker image pull		Pobierz obraz z Docker Hub lub innego rejestru. Kontenery nie mogą działać bez obrazów
	docker pull ubuntu	Pobierz najnowszy dostępny obraz Ubuntu
	docker pull nginx:alpine	Pobierz lekki obraz Nginx oparty na Alpine Linux
	docker pull redis:7	Pobierz obraz Redis w wersji 7
docker container run		Utwórz i uruchom nowy kontener z obrazu
	docker run -it ubuntu bash	Uruchom Ubuntu z interaktywnym terminalem Bash
	docker run -d nginx	Uruchom Nginx w trybie odłączonym (w tle)
	docker run -p 8080:80 nginx	Uruchom Nginx i zbindowaj port kontenera 80 do portu hosta 8080
docker container ls		Wyświetl działające kontenery
	docker ps	Pokaż tylko działające kontenery
	docker ps -a	Pokaż wszystkie kontenery, w tym zatrzymane
	docker ps --format '{{.Names}}'	Wyświetl tylko nazwy kontenerów
docker container start		Uruchom jeden lub więcej zatrzymanych kontenerów
	docker start container_name	Uruchom kontener po nazwie
	docker start $(docker ps -aq)	Uruchom wszystkie kontenery
	docker start -ai container_name	Uruchom kontener i dołącz interaktywny terminal
docker container stop		Zatrzymaj działający kontener
	docker stop container_name	Zatrzymaj kontener po nazwie
	docker stop $(docker ps -q)	Zatrzymaj wszystkie działające kontenery
	docker stop -t 5 container_name	Zatrzymaj kontener dając mu 5 sekund na zakończenie procesów
docker container restart		Uruchom ponownie kontener
	docker restart container_name	Uruchom ponownie określony kontener
	docker restart $(docker ps -q)	Uruchom ponownie wszystkie działające kontenery
	docker restart -t 10 container_name	Uruchom ponownie kontener z opóźnieniem 10 sekund
docker container rm		Usuń kontener
	docker rm container_name	Usuń określony zatrzymany kontener
	docker rm $(docker ps -aq)	Usuń wszystkie zatrzymane kontenery
	docker rm -f container_name	Wymuś usunięcie działającego kontenera
docker image ls		Wyświetl pobrane obrazy
	docker images	Pokaż wszystkie obrazy na hoście
	docker images -a	Pokaż wszystkie obrazy, w tym warstwy pośrednie
	docker images --format '{{.Repository}}:{{.Tag}}'	Wyświetl tylko nazwy i tagi obrazów
docker image rm		Usuń jeden lub więcej obrazów z lokalnego magazynu
	docker rmi test1:latest	Usuń obraz z tagiem latest z repozytorium test1
	docker rmi 1a2b3c4d5e6f	Usuń obraz po jego ID
	docker rmi $(docker images -q)	Usuń wszystkie obrazy (używaj ostrożnie!)

🔁 Zarządzanie kontenerami

Polecenie	Przykład	Opis
docker container exec		Uruchom polecenie wewnątrz działającego kontenera
	docker exec -it container bash	Uruchom interaktywną powłokę bash w kontenerze o nazwie container
	docker exec container ls /app	Wykonaj polecenie ls w katalogu /app wewnątrz kontenera
	docker exec -d container touch /tmp/testfile	Uruchom polecenie w kontenerze w trybie odłączonym (bez oczekiwania)
docker container logs		Wyświetl logi kontenera
	docker logs container	Pokaż wszystkie logi z kontenera container
	docker logs -f container	Śledź logi kontenera w czasie rzeczywistym
	docker logs --tail 50 container	Pokaż ostatnie 50 linii logów
docker inspect		Pobierz szczegółowe informacje JSON o kontenerze lub obrazie
	docker inspect container	Wyświetl szczegóły kontenera container
	docker inspect --format '{{.NetworkSettings.IPAddress}}' container	Pokaż adres IP kontenera
docker container stats		Pokaż statystyki użycia zasobów kontenerów w czasie rzeczywistym
	docker stats	Wyświetl CPU, pamięć, sieć i dysk dla wszystkich kontenerów
	docker stats container_name	Pokaż statystyki tylko dla konkretnego kontenera
	docker stats --no-stream	Pokaż jednorazowy zrzut statystyk i zakończ
docker container rename		Zmień nazwę kontenera
	docker rename old_name new_name	Zmień nazwę kontenera z old_name na new_name
docker container cp		Kopiuj pliki między kontenerem a hostem
	docker cp container:/src/file.txt ./file.txt	Skopiuj plik z kontenera do bieżącego katalogu hosta
	docker cp ./config.yaml container:/app/config.yaml	Skopiuj plik z hosta do kontenera
	docker cp CONTAINER:/var/logs/app.log - | tar x -O | grep "ERROR"	Strumieniuj plik logu z kontenera i filtruj linie z “ERROR” bez zapisywania na dysku
docker container top		Wyświetl działające procesy w kontenerze
	docker top container	Pokaż procesy w kontenerze container
docker container pause		Wstrzymaj wszystkie procesy w kontenerze
	docker pause container	Wstrzymaj kontener container
docker container unpause		Wznów wstrzymany kontener
	docker unpause container	Wznów kontener container
docker container update		Zaktualizuj ustawienia kontenera bez restartu
	docker update --memory 500m container	Ogranicz użycie pamięci kontenera do 500 MB

🧱 Obrazy i Dockerfile

Polecenie	Przykład	Opis
docker buildx build		Zbuduj obraz Dockera z Dockerfile
	docker build -t my_image .	Zbuduj obraz z tagiem my_image z bieżącego katalogu
	docker build -t my_image:1.0 .	Zbuduj obraz z tagiem w wersji 1.0
	docker build --no-cache -t my_image .	Zbuduj obraz bez używania cache dla czystej kompilacji
docker container commit		Utwórz obraz z bieżącego stanu kontenera
	docker commit container my_img:v1	Utwórz obraz my_img z tagiem v1 z kontenera container
	docker commit -m "Added config" container my_img:v2	Utwórz obraz z komunikatem commit
	docker commit -a "John Doe" container my_img:latest	Utwórz obraz z podanym autorem
docker image tag		Dodaj lub zmień tag obrazu
	docker tag my_image myrepo/my_image:latest	Dodaj tag do wypchnięcia do rejestru myrepo
	docker tag my_image:1.0 my_image:stable	Utwórz tag stable dla obrazu z tagiem 1.0
	docker tag my_image my_image:backup	Dodaj tag backup do lokalnego obrazu
docker image push		Wypchnij obraz do Docker Hub lub innego rejestru
	docker push myrepo/my_image:latest	Wypchnij obraz z tagiem latest do repozytorium myrepo
	docker push myrepo/my_image:1.0	Wypchnij obraz z tagiem 1.0
	docker push myrepo/my_image	Wypchnij obraz z domyślnym tagiem latest
docker login		Zaloguj się do Docker Hub lub innego rejestru
	docker login	Podaj nazwę użytkownika i hasło interaktywnie dla Docker Hub
	docker login myregistry.local:5000	Zaloguj się do prywatnego rejestru
	docker login -u username -p password	Zaloguj się przy użyciu nazwy użytkownika i hasła (niezalecane)
docker logout		Wyloguj się z Docker Hub lub innego rejestru
	docker logout	Wyloguj się z Docker Hub
	docker logout myregistry.local:5000	Wyloguj się z prywatnego rejestru
HEALTHCHECK		Instrukcja Dockerfile do automatycznego sprawdzania stanu kontenera
	HEALTHCHECK --interval=30s --timeout=5s --retries=3 CMD curl -f http://localhost/ || exit 1	Dodaj test zdrowia sprawdzający dostępność usługi co 30 sekund
	docker inspect --format='{{json .State.Health}}' container_name	Sprawdź status healthcheck działającego kontenera

🔌 Sieci i wolumeny

Polecenie	Przykład	Opis
docker network ls		Wyświetl wszystkie sieci Dockera
	docker network ls	Pokaż wszystkie utworzone sieci Dockera
	docker network ls --filter driver=bridge	Pokaż tylko sieci z driverem bridge
	docker network ls --format '{{.Name}}'	Pokaż tylko nazwy sieci
docker network create		Utwórz nową sieć Dockera
	docker network create my_net	Utwórz sieć my_net z ustawieniami domyślnymi
	docker network create --driver bridge my_bridge_net	Utwórz sieć z driverem bridge
	docker network create --subnet=192.168.10.0/24 my_custom_net	Utwórz sieć z określonym subnetem
docker network connect		Podłącz kontener do sieci
	docker network connect my_net container	Podłącz kontener container do sieci my_net
	docker network connect --alias db_net my_net container	Podłącz z aliasem db_net
docker network disconnect		Odłącz kontener od sieci
	docker network disconnect my_net container	Odłącz kontener container od sieci my_net
docker volume ls		Wyświetl wszystkie wolumeny Dockera
	docker volume ls	Pokaż wszystkie wolumeny Dockera
	docker volume ls --filter dangling=true	Pokaż nieużywane wolumeny
docker volume create		Utwórz nowy wolumen Dockera
	docker volume create my_vol	Utwórz wolumen o nazwie my_vol
	docker volume create --driver local --opt type=tmpfs my_tmp_vol	Utwórz tymczasowy wolumen przy użyciu tmpfs
docker volume inspect		Pokaż szczegółowe informacje o wolumenie
	docker volume inspect my_vol	Wyświetl szczegóły wolumenu my_vol w formacie JSON
docker volume rm		Usuń jeden lub więcej wolumenów
	docker volume rm my_vol	Usuń wolumen o nazwie my_vol
	docker volume rm $(docker volume ls -qf dangling=true)	Usuń wszystkie nieużywane wolumeny

🧩 Wtyczki Dockera

Polecenie	Przykład	Opis
docker plugin ls		Wyświetl zainstalowane wtyczki Dockera
	docker plugin ls	Wyświetl wszystkie wtyczki i ich status
docker plugin install		Zainstaluj wtyczkę Dockera z rejestru
	docker plugin install vieux/sshfs	Zainstaluj wtyczkę wolumenu SSHFS
	docker plugin install store/weaveworks/net-plugin:latest_release	Zainstaluj wtyczkę sieciową Weave
docker plugin disable		Wyłącz zainstalowaną wtyczkę
	docker plugin disable vieux/sshfs	Wyłącz wtyczkę SSHFS
docker plugin enable		Włącz wcześniej wyłączoną wtyczkę
	docker plugin enable vieux/sshfs	Włącz wtyczkę SSHFS
docker plugin rm		Usuń wtyczkę Dockera
	docker plugin rm vieux/sshfs	Usuń wtyczkę SSHFS

📋 Docker Compose

Polecenie	Przykład	Opis
docker compose up		Uruchom kontenery zdefiniowane w docker-compose.yml
	docker compose up	Uruchom wszystkie usługi w bieżącym katalogu w trybie interaktywnym
	docker compose up -d	Uruchom usługi w trybie odłączonym (w tle)
	docker compose up --build	Zbuduj obrazy przed uruchomieniem usług
docker compose down		Zatrzymaj i usuń kontenery, sieci i wolumeny utworzone przez up
	docker compose down	Zatrzymaj wszystkie uruchomione usługi i usuń powiązane zasoby
	docker compose down --volumes	Usuń także wolumeny utworzone przez Compose
	docker compose down --rmi all	Usuń także obrazy utworzone przez Compose
docker compose logs		Wyświetl logi wszystkich lub wybranych usług
	docker compose logs	Pokaż logi wszystkich usług
	docker compose logs -f	Śledź logi w czasie rzeczywistym
	docker compose logs web	Pokaż logi tylko dla usługi web
docker compose exec		Uruchom polecenie w działającym kontenerze usługi
	docker compose exec web bash	Wejdź do interaktywnej powłoki bash w kontenerze usługi web
	docker compose exec db ls /var/lib/postgresql	Uruchom polecenie ls w kontenerze bazy danych
	docker compose exec -d worker touch /tmp/done	Uruchom polecenie w kontenerze worker w trybie odłączonym
docker compose build		Buduj lub przebudowuj obrazy usług
	docker compose build	Zbuduj wszystkie obrazy zdefiniowane w docker-compose.yml
	docker compose build web	Zbuduj tylko obraz usługi web
	docker compose build --no-cache	Buduj obrazy bez użycia cache
docker compose ps		Pokaż status wszystkich usług i kontenerów
	docker compose ps -a	Pokaż wszystkie kontenery, w tym zatrzymane
	docker compose ps --services	Pokaż tylko nazwy usług
docker compose pull		Pobierz/zaktualizuj obrazy usług z rejestru
	docker compose pull web	Pobierz obraz tylko dla usługi web
	docker compose pull --ignore-pull-failures	Kontynuuj pobieranie nawet jeśli niektóre obrazy się nie powiodą
docker compose restart		Uruchom ponownie wszystkie lub wybrane usługi
	docker compose restart db	Uruchom ponownie tylko usługę db
	docker compose restart -t 10	Uruchom ponownie usługi z 10-sekundowym limitem czasu
docker compose config		Wyświetl końcową konfigurację Compose w formacie YAML
	docker compose config --services	Wypisz wszystkie usługi w konfiguracji
	docker compose config --volumes	Wypisz wszystkie wolumeny zdefiniowane w konfiguracji
docker compose start		Uruchom zatrzymane usługi bez ponownego tworzenia kontenerów
	docker compose start web	Uruchom usługę web
	docker compose start db api	Uruchom wiele usług naraz
docker compose stop		Zatrzymaj usługi bez usuwania kontenerów
	docker compose stop web	Zatrzymaj usługę web
	docker compose stop -t 5	Zatrzymaj usługi z 5-sekundowym limitem czasu

📤 Eksport i Import

Polecenie	Przykład	Opis
docker image save		Zapisz jeden lub więcej obrazów Dockera do archiwum tar w celu późniejszego importu lub transferu
	docker save -o image.tar my_img:tag	Zapisz obraz Dockera do pliku archiwum tar
	docker save my_image > my_image.tar	Alternatywny sposób zapisania obrazu do pliku
	docker save -o redis_latest.tar redis:latest	Zapisz określony obraz Redis do pliku
docker image load		Wczytaj obrazy Dockera z wcześniej zapisanego archiwum tar
	docker load < image.tar	Wczytaj obraz Dockera z pliku archiwum tar
	docker load --input redis_latest.tar	Wczytaj obraz wskazując plik przez parametr
	docker load --quiet < my_image.tar	Wczytaj obraz bez pokazywania postępu
docker container export		Eksportuj system plików kontenera jako archiwum tar bez historii obrazu i metadanych
	docker export container > file.tar	Eksportuj system plików kontenera do archiwum
	docker export my_container > my_container_fs.tar	Eksportuj kontener po nazwie
	docker export -o container_fs.tar container_id	Eksportuj po ID kontenera używając flagi -o
docker image import		Utwórz nowy obraz z archiwum tar systemu plików
	docker import file.tar new_img	Zaimportuj plik archiwum jako nowy obraz Dockera
	docker import https://example.com/image.tar my_new_image	Zaimportuj obraz bezpośrednio z URL
	docker import - my_image < file.tar	Zaimportuj ze standardowego wejścia

🧹 Czyszczenie i diagnostyka

Polecenie	Przykład	Opis
docker system df		Pokaż użycie dysku przez Dockera: wolumeny, obrazy, kontenery i pamięć podręczną build
	docker system df -v	Szczegółowe wyjście z informacjami o każdym obrazie, kontenerze i wolumenie
	docker system df --format '{{json .}}'	Wyjście w formacie JSON
docker system prune		Usuń wszystkie nieużywane dane Dockera: zatrzymane kontenery, nieużywane sieci, wiszące obrazy i pamięć podręczną build
	docker system prune -a	Usuń nieużywane obrazy, w tym pośrednie
	docker system prune --volumes	Usuń nieużywane wolumeny wraz z innymi zasobami
docker image prune		Usuń nieużywane obrazy Dockera, w tym wiszące warstwy
	docker image prune -a	Usuń wszystkie nieużywane obrazy, w tym wiszące
	docker image prune --filter "until=24h"	Usuń obrazy starsze niż 24 godziny
docker container prune		Usuń zatrzymane kontenery pasujące do filtrów lub wszystkie, jeśli nie podano filtrów
	docker container prune --filter "until=24h"	Usuń zatrzymane kontenery starsze niż 24 godziny
	docker container prune --force	Usuń bez pytania o potwierdzenie

🐝 Docker Swarm

Polecenie	Przykład	Opis
docker swarm init		Zainicjuj nowy klaster Docker Swarm na bieżącym węźle
	docker swarm init --advertise-addr 192.168.1.100	Zainicjuj klaster podając adres IP
	docker swarm init --listen-addr 0.0.0.0:2377	Zainicjuj z określonym portem nasłuchiwania
docker service create		Utwórz nową usługę w klastrze Swarm
	docker service create --name nginx nginx	Utwórz usługę Nginx w Swarm
	docker service create --replicas 3 --name web webserver	Utwórz usługę z 3 replikami
	docker service create --name redis --publish 6379:6379 redis	Utwórz usługę z mapowaniem portów
docker stack deploy		Wdróż stos usług do klastra Swarm na podstawie pliku Compose
	docker stack deploy -c docker-compose.yml mystack	Wdróż stos z pliku compose
	docker stack deploy --with-registry-auth -c compose.yml mystack	Wdróż z przekazywaniem uwierzytelnienia rejestru
	docker stack deploy -c swarm-compose.yml mystack	Użyj alternatywnego pliku compose dla stosu
docker stack rm		Usuń jeden lub więcej stosów z klastra Swarm
	docker stack rm mystack	Usuń stos mystack
	docker stack rm	Usuń wszystkie stosy (niezalecane)
	docker stack rm mystack && docker swarm leave --force	Usuń stos i opuść Swarm

💼 Zaawansowane użycie Dockera

🚀 Profesjonalne polecenia Dockera

Polecenie	Przykład	Opis
docker buildx		Zaawansowane narzędzie do budowania obrazów zastępujące docker build. Obsługuje multi-platformę, cache, budowanie równoległe i eksport do różnych formatów. Przydatne dla CI/CD i rozwoju wieloplatformowego
	docker buildx build --platform linux/arm64,linux/amd64 -t myimg:multi .	Zbuduj obraz wieloplatformowy (ARM i x86 jednocześnie)
	docker buildx build --load -t localimg .	Zbuduj obraz i załaduj go do lokalnego cache Dockera
	docker buildx build --push --platform linux/amd64,linux/arm64 -t repo/app:latest .	Zbuduj i wypchnij obraz wieloplatformowy do rejestru
docker context		Zarządzaj kontekstami Dockera do pracy ze zdalnymi lub wieloma środowiskami. Umożliwia szybkie przełączanie między lokalnym a zdalnym Docker Engine
	docker context create myremote --docker "host=ssh://user@host"	Utwórz kontekst do połączenia ze zdalnym hostem Dockera
	docker context use myremote	Przełącz na zdalny kontekst
	docker context ls	Wyświetl dostępne konteksty i aktywny
docker system events		Nasłuchuj zdarzeń Dockera w czasie rzeczywistym, z filtrowaniem po typie zdarzeń (np. uruchomienie kontenera). Przydatne do monitorowania i automatyzacji
	docker events --filter 'event=start'	Pokaż tylko zdarzenia uruchomienia kontenerów
	docker events --since 1h --until 10m	Pokaż zdarzenia z ostatniej godziny do 10 minut temu
	docker events --filter 'type=network'	Pokaż tylko zdarzenia sieciowe
	docker events --filter 'image=nginx'	Pokaż zdarzenia związane z obrazem nginx
docker container update		Zmień limity zasobów i ustawienia działającego kontenera bez restartu
	docker update --cpus 2 --memory 1g my_container	Ustaw limit na 2 CPU i 1 GB RAM
	docker update --restart unless-stopped my_container	Ustaw politykę automatycznego restartu na unless-stopped
	docker update --pids-limit 200 my_container	Ogranicz liczbę procesów do 200
docker container diff		Pokaż zmiany systemu plików w kontenerze w porównaniu do jego pierwotnego obrazu. Przydatne do debugowania i audytu
	docker diff my_container	Pokaż wszystkie zmiany w systemie plików kontenera
	docker diff my_container | grep '^A'	Pokaż tylko dodane pliki (A — Added)
docker image history		Wyświetl historię warstw obrazu: polecenia budowy, rozmiar każdej warstwy i czas utworzenia. Przydatne do optymalizacji i audytu
	docker history my_image	Pokaż historię warstw obrazu
	docker history --no-trunc my_image	Pokaż pełne polecenia budowy bez skracania
	docker history --format "{{.CreatedBy}}: {{.Size}}" my_image	Wyświetl tylko polecenia budowy i rozmiary warstw

🛠 Przydatne praktyki Dockera i automatyzacja

• Minimalizuj rozmiar obrazu
  Używaj bazowych obrazów takich jak alpine lub scratch dla minimalnego rozmiaru.
  Aby spłaszczyć warstwy, możesz użyć --squash podczas budowy (wymaga włączonych funkcji eksperymentalnych).
  Usuń także pliki tymczasowe i cache w jednej warstwie:

  RUN apk add --no-cache curl && rm -rf /var/cache/apk/*

• Minimalizuj liczbę warstw
  Łącz polecenia w jednym RUN, aby zmniejszyć liczbę warstw i końcowy rozmiar obrazu:

  RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*

• Optymalizuj budowę Dockerfile
  Używaj budowy wieloetapowej, aby w końcowym obrazie pozostały tylko potrzebne pliki.
  Najpierw kopiuj i instaluj zależności, potem kod — poprawia to cache warstw i przyspiesza przebudowę.

• Oddzielaj sekrety i konfiguracje
  Nigdy nie przechowuj plików .env, kluczy API ani prywatnych certyfikatów w obrazie.
  Używaj do konfiguracji:

  • docker secret (w Swarm)
    
  • zmienne środowiskowe (-e VAR=value lub .env)
    

  • zewnętrzne wolumeny dla konfiguracji

• Sekrety w czasie budowy (BuildKit)
  Do bezpiecznego przekazywania sekretów podczas budowy użyj flagi --secret:

  docker buildx build --secret id=mysecret,src=./secret.txt .

  W Dockerfile sekret jest dostępny pod /run/secrets/mysecret:

  RUN --mount=type=secret,id=mysecret cat /run/secrets/mysecret

  🛡 To zapobiega przechowywaniu sekretów w warstwach obrazu.

• Rootless Docker
  Uruchamianie Dockera bez uprawnień root zwiększa bezpieczeństwo i zmniejsza ryzyko kompromitacji hosta.
  Aby włączyć:

  dockerd-rootless-setuptool.sh install
  export PATH=/usr/bin:$PATH

  Sprawdź:

  docker info | grep Rootless

  ⚠ Niektóre funkcje (np. przekierowanie portów <1024) będą niedostępne.

• Skanuj obrazy pod kątem podatności
  Użyj wbudowanych narzędzi:

  docker scan my_image

  Lub nowego CLI:

  docker scout cves my_image

  To pomaga wykrywać podatności w obrazach bazowych i zależnościach.

• Monitoruj użycie zasobów
  Ograniczaj kontenery pamięcią, CPU i liczbą procesów:

  docker run --memory=512m --cpus="1.5" --pids-limit=200 myimage

  Zapobiega to nadmiernemu zużyciu zasobów.
  Możesz także ograniczać I/O:

  docker run --device-read-bps /dev/sda:1mb --device-write-bps /dev/sda:1mb myimage

  Przydatne dla kontenerów, które nie powinny przeciążać podsystemu dyskowego.

• Automatyczne czyszczenie
  Regularnie usuwaj nieużywane obrazy, kontenery, wolumeny i sieci:

  docker system prune -af --volumes

  ⚠ Uważaj: to polecenie usuwa wszystkie nieużywane zasoby.

  Do selektywnego czyszczenia używaj:

  docker image prune --filter "until=24h"

• Integracja CI/CD
  Osadź budowanie, testy i wdrażanie w GitHub Actions, GitLab CI, Jenkins pipelines.
  Przykładowy krok GitHub Actions:

  - run: docker build -t myapp:${GITHUB_SHA} .
  - run: docker push myapp:${GITHUB_SHA}

• Logowanie i monitorowanie
  Podłącz sterowniki logowania (--log-driver) do scentralizowanych systemów: ELK, Loki, Splunk.
  Używaj Prometheus + cAdvisor do metryk kontenerów.

• Wdrożenie produkcyjne
  Oddziel konfiguracje dla developmentu i produkcji używając docker-compose.override.yml.
  Dla wysokiej dostępności i skalowania używaj:

  • Docker Swarm
    

  • Kubernetes

🐞 Debugowanie i profilowanie kontenerów Dockera

Polecenie	Przykład	Opis
docker container exec		Uruchamia polecenie wewnątrz działającego kontenera, zapewniając interaktywny dostęp lub możliwość uruchamiania procesów w odizolowanym środowisku kontenera
	docker exec -it my_container bash	Uruchom interaktywny terminal (bash) wewnątrz działającego kontenera
	docker exec -it my_container sh	Uruchom minimalną powłokę wewnątrz kontenera (jeśli bash nie jest dostępny)
	docker exec my_container ls /app	Uruchom polecenie w kontenerze bez trybu interaktywnego
docker container logs		Wyświetla logi określonego kontenera, umożliwiając podgląd wyjścia i zdarzeń związanych z jego działaniem do diagnostyki i monitorowania
	docker logs -f --tail 100 my_container	Zobacz ostatnie 100 linii logów z transmisją w czasie rzeczywistym
	docker logs my_container	Pokaż wszystkie dostępne logi kontenera
	docker logs --since 1h my_container	Pokaż logi z ostatniej godziny
docker inspect		Zwraca szczegółowe informacje o obiekcie Dockera (kontenerze, obrazie, sieci itd.) w formacie JSON, w tym konfigurację i stan
	docker inspect my_container	Pobierz pełne informacje JSON o kontenerze
	docker inspect --format '{{.State.Pid}}' my_container	Pobierz PID głównego procesu kontenera na hoście
	docker inspect --format '{{.NetworkSettings.IPAddress}}' my_container	Pokaż adres IP kontenera
nsenter (with strace)		Narzędzie Linuksa do wchodzenia w przestrzenie nazw innego procesu (tu: kontenera). Używane z strace do śledzenia wywołań systemowych wewnątrz kontenera w celach debugowania
	nsenter --target $(docker inspect --format '{{.State.Pid}}' my_container) --mount --uts --ipc --net --pid strace -p 1	Wejdź w przestrzenie nazw kontenera i śledź wywołania systemowe procesu 1
	nsenter --target $(docker inspect --format '{{.State.Pid}}' my_container) --mount --uts --ipc --net --pid bash	Otwórz powłokę bash wewnątrz przestrzeni nazw kontenera
	nsenter --target $(docker inspect --format '{{.State.Pid}}' my_container) --net netstat -tulnp	Zobacz otwarte porty wewnątrz kontenera
tcpdump (inside container)		Konsolowe narzędzie do przechwytywania i analizy ruchu sieciowego. Używane w kontenerze do diagnozowania problemów sieciowych, analizy pakietów i monitorowania połączeń
	docker exec -it my_container tcpdump -i any	Przechwyć i analizuj ruch sieciowy wewnątrz kontenera
	docker exec -it my_container tcpdump -nn port 80	Przechwyć ruch tylko na porcie 80
	docker exec -it my_container tcpdump -w /tmp/dump.pcap	Zapisz ruch do pliku do późniejszej analizy
docker container stats		Pokazuje bieżące metryki użycia zasobów (CPU, pamięć, sieć, dysk) dla jednego lub wielu kontenerów w czasie rzeczywistym
	docker stats my_container	Wyświetl w czasie rzeczywistym użycie CPU, pamięci, sieci i dysku przez kontener
	docker stats	Pokaż statystyki dla wszystkich kontenerów
	docker stats --no-stream	Wyświetl statystyki jednokrotnie i zakończ
docker container top		Wyświetla listę procesów działających w kontenerze, podobnie jak ps w Linuksie, aby analizować aktywność kontenera
	docker top my_container	Pokaż procesy działające wewnątrz kontenera
	docker top my_container aux	Użyj alternatywnego formatu wyjściowego, jak ps aux
	docker top my_container -eo pid,cmd	Pokaż tylko PID i polecenia procesów
docker diff		Pokazuje zmiany w systemie plików kontenera w porównaniu do obrazu bazowego, wskazując dodane, zmienione lub usunięte pliki
	docker diff my_container	Pokaż zmiany w systemie plików kontenera względem obrazu bazowego
	docker diff my_container | grep '^A'	Pokaż tylko dodane pliki (A — Added)
	docker diff my_container | grep '^C'	Pokaż tylko zmienione pliki (C — Changed)
docker cp		Kopiuje pliki i katalogi między kontenerem a hostem, umożliwiając wymianę danych i tworzenie kopii zapasowych
—	—	—
	docker cp my_container:/path/to/file ./file	Skopiuj plik z kontenera na hosta
	docker cp ./config.yaml my_container:/app/config.yaml	Skopiuj plik z hosta do kontenera
	docker cp my_container:/var/log/app.log - | tar x -O | grep "ERROR"	Skopiuj plik logu i przefiltruj linie z błędami bez zapisywania na dysk

💡 Do zaawansowanego debugowania możesz używać nsenter, strace, tcpdump, gdb i innych niskopoziomowych narzędzi.

💼 Zaawansowane użycie Docker Compose

🚀 Profesjonalne polecenia Docker Compose

Polecenie	Przykład	Opis
docker compose up		Uruchamia i zarządza cyklem życia określonych usług z pliku docker-compose.yml z możliwością działania w tle
	docker compose up -d web db	Uruchom tylko usługi web i db w trybie odłączonym
	docker compose up --build	Przebuduj obrazy przed uruchomieniem usług
	docker compose up --remove-orphans	Usuń kontenery niezdefiniowane w bieżącym pliku compose
docker compose build		Buduje obrazy dla usług zgodnie z opisem w pliku compose z kontrolą cache i równoległością
	docker compose build --no-cache	Przebuduj obrazy całkowicie bez użycia cache
	docker compose build --parallel	Buduj wszystkie usługi równolegle, aby przyspieszyć proces
	docker compose build web	Zbuduj obraz tylko dla usługi web
docker compose pull		Pobiera najnowsze wersje obrazów z rejestru dla wszystkich lub określonych usług
	docker compose pull	Pobierz obrazy dla wszystkich usług
	docker compose pull db	Pobierz obraz tylko dla usługi db
	docker compose pull --ignore-pull-failures	Kontynuuj wykonywanie ignorując błędy podczas pobierania obrazów
docker compose restart		Ponownie uruchamia wszystkie lub określone usługi bez ponownego tworzenia kontenerów
	docker compose restart	Uruchom ponownie wszystkie usługi w bieżącym projekcie
	docker compose restart worker	Uruchom ponownie tylko usługę worker
	docker compose restart web db	Uruchom ponownie wiele usług naraz
docker compose exec		Wykonuje polecenie w działającym kontenerze usługi z opcjonalnym trybem interaktywnym
	docker compose exec db psql -U user -d database	Uruchom psql w kontenerze usługi db
	docker compose exec web sh	Otwórz powłokę w kontenerze web
	docker compose exec api curl http://localhost:8080	Wykonaj żądanie curl z kontenera usługi api
docker compose config		Wyświetla końcową konfigurację Compose uwzględniając wszystkie pliki i zmienne środowiskowe
	docker compose config	Pokaż scaloną konfigurację w formacie YAML
	docker compose config --services	Wypisz wszystkie usługi
	docker compose config --environment	Pokaż wszystkie zmienne środowiskowe używane przez usługi
docker compose watch		Automatycznie restartuje usługi przy zmianach w plikach źródłowych, przydatne w trakcie developmentu
	docker compose watch	Rozpocznij obserwację plików i restartuj usługi przy zmianach
docker compose events		Strumieniuj zdarzenia Compose: uruchamianie, zatrzymywanie, aktualizacje usług
	docker compose events --json	Odbieraj zdarzenia w formacie JSON
docker compose rm		Usuwa zatrzymane kontenery usług
	docker compose rm web db	Usuń kontenery usług web i db
docker compose pause		Wstrzymaj działanie usług
	docker compose pause api	Wstrzymaj usługę api
docker compose unpause		Wznów wstrzymane usługi
	docker compose unpause api	Wznów usługę api
docker compose create		Tworzy kontenery bez ich uruchamiania
	docker compose create web db	Utwórz kontenery dla web i db, ale ich nie uruchamiaj
docker compose images		Pokazuje listę obrazów używanych przez usługi
	docker compose images	Wyświetl obrazy wszystkich usług
docker compose top		Pokazuje procesy działające w kontenerach usług
	docker compose top web	Wyświetl procesy w kontenerach usługi web

🛠 Przydatne praktyki i automatyzacja z Docker Compose

• Oddzielanie środowisk
  Używaj oddzielnych plików docker-compose.override.yml dla różnych środowisk — development, staging, production. Pomaga to izolować konfiguracje i unikać konfliktów ustawień.
  Możesz też łączyć wiele plików konfiguracyjnych przy pomocy flagi -f:

  docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d

  Używaj różnych plików .env (.env.dev, .env.prod itd.) do zarządzania zmiennymi środowiskowymi.

• Bezpieczne przechowywanie sekretów
  Nie umieszczaj danych wrażliwych (haseł, tokenów) bezpośrednio w plikach Compose. Zamiast tego używaj:

  • plików .env dla zmiennych środowiskowych (pamiętaj, że pliki .env nie są szyfrowane i nie powinny trafiać do repozytoriów publicznych)
    
  • docker secret i docker config do bezpiecznego zarządzania sekretami i konfiguracjami w Docker Swarm
    
  • zewnętrznych wolumenów dla plików konfiguracyjnych zawierających sekrety
    

  • zewnętrznych systemów zarządzania sekretami (np. HashiCorp Vault, AWS Secrets Manager)

• Kolejność uruchamiania z depends_on i healthcheck
  Aby usługi czekały na gotowość zależności:

  services:
    db:
      image: postgres
      healthcheck:
        test: ["CMD-SHELL", "pg_isready -U postgres"]
        interval: 10s
        retries: 5
    api:
      image: my_api
      depends_on:
        db:
          condition: service_healthy

• Minimalizacja przestoju podczas aktualizacji
  Przed aktualizacją usług uruchom:

  docker compose pull && docker compose up -d --remove-orphans

  Opcja -d uruchamia kontenery w tle, a --remove-orphans usuwa kontenery niezdefiniowane w bieżących konfiguracjach.
  Aby całkowicie zatrzymać i usunąć stare kontenery, jeśli to konieczne:

  docker compose down --remove-orphans

  Zapewnia to wczytanie świeżych obrazów i usunięcie nieużywanych kontenerów bez przestojów.

• Hot Reload kodu w trakcie developmentu
  Używaj volumes, aby montować lokalne katalogi w kontenerach. Pozwala to natychmiast zastosować zmiany w kodzie bez przebudowy obrazów.
  Zwróć uwagę na problemy z uprawnieniami plików i cache systemu plików, szczególnie w Windows i macOS, aby uniknąć problemów z wydajnością.

• Hot Reload kodu bez wolumenów (Compose 2.22+)

  develop:
    watch:
      - path: ./src
        action: sync
        target: /app

• Centralne logowanie usług
  Przekierowuj logi kontenerów do systemów monitorowania i agregacji logów, takich jak ELK Stack, Loki, Prometheus i Fluentd, dla łatwej analizy i alertów.
  Używaj sterowników logowania Dockera (--log-driver), aby włączyć scentralizowane zbieranie i przetwarzanie logów.
  Konfiguruj sterowniki logowania dla kontenerów w Compose:

  services:
    api:
      image: my_api
      logging:
        driver: "json-file"
        options:
          max-size: "10m"
          max-file: "3"

• Automatyczny restart usług
  Skonfiguruj politykę restartu w docker-compose.yml:

  restart: unless-stopped

  Inne polityki restartu obejmują:

  • no — brak automatycznego restartu (domyślnie)
    
  • always — zawsze restartuj kontener
    

  • on-failure — restartuj tylko przy błędach (opcjonalnie z liczbą ponowień)

  W produkcji unless-stopped to optymalny wybór zapewniający odporność usług.
  Umożliwia to automatyczne odzyskiwanie usług po awariach lub restartach hosta.

• Profile usług
  Pozwalają uruchamiać tylko określone grupy usług:

  services:
    db:
      image: postgres
      profiles: ["backend"]
    web:
      image: nginx
      profiles: ["frontend"]

  Aby uruchomić tylko profil frontend:

  docker compose --profile frontend up

🐞 Debugowanie i profilowanie usług w Docker Compose

Polecenie	Przykład	Opis
docker compose exec		Wykonuje polecenie w działającej usłudze, zapewniając dostęp do kontenera lub uruchamianie pojedynczych procesów
	docker compose exec web sh	Otwórz powłokę w kontenerze usługi web
	docker compose exec db psql -U user -d database	Uruchom polecenie psql w kontenerze usługi db
docker compose logs		Wyświetl logi usług do diagnostyki i monitorowania
	docker compose logs -f db	Zobacz logi usługi db w czasie rzeczywistym
	docker compose logs --tail=50 api	Pokaż ostatnie 50 linii logów usługi api
	docker compose logs --since=1h web	Pokaż logi z ostatniej godziny dla usługi web
docker inspect		Wyświetl szczegółowe informacje o kontenerze uruchamiającym usługę
	docker inspect $(docker compose ps -q web)	Pobierz JSON ze szczegółowymi informacjami o kontenerze usługi web
docker container stats		Monitoruj użycie zasobów kontenerów uruchamiających usługi
	docker stats $(docker compose ps -q worker)	Śledź CPU, pamięć i inne zasoby kontenera usługi worker
docker compose run --rm		Uruchom tymczasowy kontener z ustawieniami usługi, przydatne do debugowania
	docker compose run --rm web sh	Uruchom jednorazowy kontener dla usługi web z interaktywną powłoką
docker container cp		Kopiuj pliki między hostem a kontenerem
	docker cp $(docker compose ps -q db):/dump.sql ./dump.sql	Skopiuj plik z kontenera usługi db na hosta

💡 Do wygodnego debugowania złożonych środowisk wielousługowych używaj docker compose run --rm, aby uruchamiać pojedyncze kontenery z potrzebnymi sieciami i wolumenami bez wpływu na główne usługi.

📚 Dodatkowe zasoby

🚫 Ignorowanie plików z .dockerignore

Dodaj pliki i foldery do .dockerignore, które nie powinny być uwzględniane w obrazie, aby zmniejszyć jego rozmiar i przyspieszyć budowę:

node_modules/
*.log
.env

⚡ Uproszczenie poleceń za pomocą aliasów

Możesz tworzyć aliasy dla często używanych poleceń, aby uruchamiać je szybciej:

alias dcu="docker compose up -d"
alias dcd="docker compose down"
alias dcb="docker compose build"

🧠 Wskazówka: porady dotyczące używania Dockera

• Nie próbuj wszystkiego zapamiętywać — używaj docker --help lub docker <polecenie> --help, aby eksplorować polecenia.
  
• Ćwicz regularnie i eksperymentuj z prostymi projektami.
  

• Zwracaj uwagę na rozmiary obrazów i usuwaj niepotrzebne pliki przez .dockerignore.

🌐 Przydatne linki

📘 Oficjalna dokumentacja Dockera — obszerne przewodniki i odniesienia do wszystkich tematów Dockera:
https://docs.docker.com/

📙 Docker Cheat Sheet — pełna oficjalna ściągawka Dockera:
https://dockerlabs.collabnix.com/docker/cheatsheet/

📗 Docker Hub — obrazy i rejestry:
https://hub.docker.com/