W poprzednim artykule wyjaśniłem, czym są obrazy i kontenery Dockera oraz dlaczego konteneryzacja pomaga uniknąć problemów z różnymi środowiskami.
Nadszedł więc czas, aby zademonstrować dockera od strony praktycznej.
Nadal korzystamy z maszyny wirtualnej Debian, na której wykonywaliśmy ćwiczenia z Gita. Mamy też repozytorium ~/devops-lab, skrypty Bash i połączenie z GitHubem. Nie będziemy zaczynać wszystkiego od zera. Rozbudujemy istniejący projekt o pliki Dockera, a gotowe zmiany zapiszemy w osobnej gałęzi.
Zaczniemy od instalacji Docker Engine. Potem uruchomimy Nginx, nauczymy się zarządzać kontenerami, sprawdzimy mapowanie portów i trwałe przechowywanie danych. W dalszej części zbudujemy obraz własnej aplikacji Node.js, a na koniec wykorzystamy Docker Compose do uruchomienia Nextcloud i PostgreSQL.
Przygotowanie laboratorium
Moja maszyna Debian działa w VirtualBoxie z interfejsem sieciowym ustawionym w trybie mostkowanym (Bridged Adapter). Dzięki temu mogę otworzyć w przeglądarce komputera fizycznego stronę uruchomioną na maszynie wirtualnej.
W terminalu przejdź do repozytorium:
cd ~/devops-lab-pr
Sprawdź jego stan:
git status
git branch --show-current
Mając czyste repozytorium, przejdź na główną gałąź:
git switch master
Następnie zaktualizuj ją:
git pull
Utwórz gałąź przeznaczoną do ćwiczeń z Dockerem:
git switch -c feature/docker-lab
Przygotuj katalogi:
mkdir -p docker/nginx-demo
mkdir -p docker/node-app
mkdir -p docker/nextcloud
Docelowo będziemy mieć mniej więcej taką strukturę:
devops-lab/
├── README.md
├── configs/
├── scripts/
└── docker/
├── nginx-demo/
│ └── index.html
├── node-app/
│ ├── app.js
│ ├── package.json
│ ├── package-lock.json
│ ├── Dockerfile
│ └── .dockerignore
└── nextcloud/
├── compose.yaml
└── .env.example
Na razie katalogi są puste. Będziemy dodawać do nich pliki podczas ćwiczeń.
Instalacja Dockera i potrzebnych zależności
Najbardziej aktualny sposób na instalacje Dockera na Debianie jak i innych systemach znajdziesz na oficjalnej stronie Dockera https://docs.docker.com/engine/install/debian/.
Poniżej masz sprawdzone przeze mnie kroki, które musisz wykonać, aby mieć gotowego do działania Dockera wraz z pluginem Docker Compose.
Usuń stare paczki, które mogą powodować konflikty
Jeżeli Docker był już instalowany z repozytoriów Debiana, mogą znajdować się w systemie pakiety kolidujące z oficjalną wersją Docker Engine. Docker zaleca usunięcie takich pakietów przed instalacją:
sudo apt remove $(dpkg --get-selections docker.io docker-compose docker-doc podman-docker containerd runc | cut -f1)
Jeśli żadnego z nich nie masz, APT może poinformować, że nie ma czego usuwać.
Skonfiguruj repozytorium apt Dockera
sudo apt update
sudo apt install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/debian
Suites: $(. /etc/os-release && echo "$VERSION_CODENAME")
Components: stable
Signed-By: /etc/apt/keyrings/docker.asc
EOF
sudo apt update
Zwróć uwagę, że używamy tutaj nazwy wersji Debiana odczytanej z systemu oraz jego architektury. Nie musisz wpisywać ich ręcznie.
Zainstaluj Dockera
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
Sprawdź czy usługa działa (zwykle startuje automatycznie)
sudo systemctl status docker
Jeśli u Ciebie nie startuje automatycznie, wówczas uruchom go ręcznie
sudo systemctl start docker
Uruchomienie pierwszego kontenera
Okej, mając zainstalowanego już Dockera, możesz przejść do uruchomienia pierwszego kontenera. Wyjaśnię Ci, co się dzieje pod maską i pokaże Ci kilka komend, które będziesz wykorzystywał praktycznie codziennie podczas pracy z kontenerami.
Na początek zademonstruję jak uruchomić najbardziej klasyczną aplikację o nazwie hello-world.

Co się dzieje po uruchomieniu tego polecenia?
- Jeśli nie masz obrazu hello-world lokalnie, Docker go pobierze z repozytoriów (pull),
- potem go uruchomi jako kontener (run),
- kontener wypisze komunikat i… zakończy działanie.
Kontenery nie muszą działać cały czas. Często jest tak, że wykona zadanie i się wyłączy.
Sprawdzenie uruchomionych kontenerów
Możesz łatwo podejrzeć, które kontenery aktualnie działają za pomocą polecenia docker ps. Polecenie to jednak nie wyświetli zatrzymanych kontenerów, aby je wyświetlić należy dodać przełącznik -a do polecenia.
Na liście powinien znajdować się kontener utworzony z obrazu hello-world, ze statusem wskazującym na zakończenie działania. Docker przypisuje kontenerom identyfikatory oraz nazwy. Możesz używać jednego albo drugiego, wykonując kolejne operacje.

Usuwanie kontenerów
Nieużywane kontenery można w łatwy sposób usunąć za pomocą polecenia docker rm, po którym należy wskazać jego nazwę lub ID. Aby sprawdzić identyfikator możesz skorzystać z polecenia, o którym wspomniałem wyżej. Można również usunąć wszystkie wstrzymane kontenery za jednym zamachem za pomocą polecenia docker system prune.

Uruchamiamy Nginx w kontenerze
Do kolejnych ćwiczeń wykorzystamy Nginx, popularny serwer WWW. Nie musimy instalować go bezpośrednio w Debianie. Pobierzemy gotowy obraz i uruchomimy kontener.
sudo docker run -d --name web nginx
Wyjaśnijmy parametry:
runtworzy i uruchamia kontener,-doznacza pracę w tle,--name webnadaje kontenerowi własną nazwę,nginx:stable-alpinewskazuje obraz, z którego korzystamy.
Sprawdź:
sudo docker ps
Powinieneś zobaczyć działający kontener Nginx.
Jak podejrzeć logi kontenera?
Podczas pracy z aplikacjami bardzo często sprawdzamy logi.
W Dockerze zrobimy to poleceniem:
sudo docker logs devops-nginx
Możemy również śledzić logi na bieżąco:
sudo docker logs -f devops-nginx
Aby zakończyć ich podgląd, naciśnij Ctrl+C.
Wejście do kontenera
Czasami chcemy sprawdzić pliki znajdujące się wewnątrz kontenera albo wykonać polecenie diagnostyczne. Do tego służy docker exec.
sudo docker exec -it devops-nginx sh
Po uruchomieniu znajdziesz się w powłoce kontenera.
Spróbuj:
pwd
ls
Możesz też sprawdzić katalog, z którego Nginx udostępnia domyślną stronę:
ls /usr/share/nginx/html
Aby wrócić do terminala Debiana:
exit
Polecenie exit kończy uruchomioną przez nas powłokę. Sam serwer Nginx nadal działa.
Uruchamianie kontenerów na określonym porcie
Uruchamiając kontenery warto wiedzieć jak ustawiać porty. Bez wskazania portów aplikacja uruchomi się tylko wewnątrz Dockera, z Twojej przeglądarki na hoście nie wejdziesz na niego po adresie. Dzieje się tak ponieważ aplikacja uruchomiona w kontenerze ma swoje porty wewnątrz kontenera. Twój komputer (host) ich nie widzi, dopóki mu nie powiesz:
„Hej Docker, wystaw ten port na zewnątrz”.
Do tego służy mapowanie portów. Najważniejsze abyś zapamiętał, że:
host:kontener
czyli: port na Twoim komputerze → port w kontenerze.
Przykład działania mapowania portów
Do zademonstrowania mapowania portów wykorzystam popularny serwer www o nazwie Nginx. Przed momentem uruchomiliśmy go w kontenerze na maszynie wirtualnej za pomocą poniższego polecenia.
docker run -d --name web nginx
Spróbujmy wejść na niego w przeglądarce. Zanim jednak odpalisz przeglądarkę, musisz dowiedzieć się jaki adres IP dostała wirtualna maszyna. Możesz to sprawdzić poleceniem ip a. Pod podanym adresem powinien działać serwer nginx. Na ten moment jednak otrzymasz błąd ze względu na to, że nie zdefiniowano mapowania portu dla hosta.

Po testach najpierw zatrzymaj poprzedni kontener:
sudo docker stop web
Następnie usuń go:
sudo docker rm web
Do zatrzymywania kontenera służy polecenie docker stop. Polecenie to w bezpieczny sposób zatrzymuje kontener. Istnieje również polecenie docker kill, które robi to natychmiast.

Aby naprawić ten problem, wystarczy zmapować port, na którym działa nginx w kontenerze, na przykładowo port 8080 w systemie hosta
docker run -d --name web -p 8080:80 nginx
Teraz wejdź w przeglądarce na adres swojego serwera (u mnie 192.168.0.110). Dopisz także port po dwukropku. Powinna pojawić się strona powitalna serwera nginx.

Przywracanie nieaktywnych kontenerów
Wspominałem o możliwości zatrzymywania kontenerów za pomocą polecenia docker stop. Możemy również przywracać zatrzymany w ten sposób kontenery za pomocą polecenia docker start.
Nie musimy wykonywać kolejnego docker run. Różnica jest prosta: docker run tworzy nowy kontener, a docker start uruchamia kontener, który już istnieje.

Na zakończenie tego ćwiczenia usuńmy go:
sudo docker stop web
sudo docker rm web
Zwolnimy w ten sposób port 8080 i nazwę kontenera.
Wolumeny w dockerze
Kontener ma swój własny system plików, ale jest on traktowany jako nietrwały. Gdy usuniesz kontener, usuwasz też jego „dysk”. Jeśli masz jakieś dane generowane i wykorzystywane przez kontenery Dockera to znikają one po usunięciu kontenera. Istnieje jednak sposób na zachowanie tych danych i do tego właśnie służą wolumeny. Omówiłem je już częściowo w artykule teoretycznym, dlatego od razu przejdę do praktyki.
Bind mount
Montowanie typu „bind” mapuje katalog lub plik z systemu plików hosta do kontenera. Umożliwia to bezpośredni dostęp do systemu plików hosta, co czyni je idealnym rozwiązaniem w sytuacjach, w których dane muszą być współdzielone między hostem a kontenerem.
Wróć do głównego katalogu repozytorium:
cd ~/devops-lab-pr
Utwórz plik strony:
echo '<h1>DevOps Lab - Docker i Git</h1>' > docker/nginx-demo/index.html
Teraz uruchom Nginx, montując nasz katalog z plikiem index.html:
sudo docker run -d \
--name devops-nginx-bind \
-p 8081:80 \
--mount type=bind,source="$(pwd)/docker/nginx-demo",target=/usr/share/nginx/html,readonly \
nginx:stable-alpine
W poleceniu wskazaliśmy katalog z Debiana oraz miejsce, pod którym będzie dostępny w kontenerze. Następnie przejdź pod adres:
http://ADRES_IP_DEBIANA:8081

Powinieneś zobaczyć napis:
DevOps Lab - Docker i Git
Teraz zmień plik bezpośrednio na Debianie:
echo '<h1>Nowa wersja strony DevOps Lab</h1>' > docker/nginx-demo/index.html
Odśwież stronę w przeglądarce. Zmiana powinna być widoczna bez przebudowy obrazu i bez restartowania kontenera. To właśnie zaleta bind mountów podczas lokalnej pracy nad projektem. Edytujemy pliki na Debianie, a kontener odczytuje ich aktualną zawartość.
Jeśli usuniesz kontener i uruchomisz go na nowo, zauważysz, że wciąż będzie miał dostęp do tego katalogu, ponieważ istnieje On poza kontenerem i nie znika wraz z usunięciem kontenera.
Dlaczego ten przykład dobrze łączy Docker z Gitem?
Sprawdź status repozytorium:
git status
Git powinien pokazać nowy, nieśledzony plik:
docker/nginx-demo/index.html
To plik projektu. Możemy go przechowywać w Git, przeglądać jego zmiany i później dołączyć do Pull Requesta. Sam kontener nie znajduje się jednak w repozytorium.
Docker zarządza jego uruchamianiem, a Git historią plików, które wykorzystujemy do przygotowania środowiska. Na razie nie twórz jeszcze commita. Zrobimy to po wykonaniu kolejnych ćwiczeń.
Zatrzymaj i usuń kontener:
docker rm -f devops-nginx-bind
Plik index.html nadal znajduje się w ~/devops-lab/docker/nginx-demo, ponieważ zapisaliśmy go na Debianie, poza kontenerem.
Named Volume
W Named volume nie wskazujemy konkretnego katalogu naszego repozytorium. Nadajemy wolumenowi nazwę, a Docker zarządza miejscem, w którym przechowuje jego dane.
1) Utwórz named volume
sudo docker volume create devops_webdata
Sprawdź jego istnienie:
sudo docker volume ls
2) Zapisz index.html do volume (trik z kontenerem pomocniczym)
Użyjemy lekkiego kontenera (busybox), żeby wrzucić plik do wolumenu. Parametr --rm powoduje automatyczne usunięcie kontenera pomocniczego po zakończeniu polecenia:
sudo docker run --rm \
-v devops_webdata:/data \
busybox:stable \
sh -c 'echo "<h1>Strona z Docker Volume</h1>" > /data/index.html'
3) Uruchom Nginx z podpiętym wolumenem
Uruchom Nginx, montując go jako katalog ze stroną:
sudo docker run -d \
--name devops-nginx-volume \
-p 8083:80 \
-v devops_webdata:/usr/share/nginx/html:ro \
nginx:stable-alpine
Natsępnie otwórz stronę:
https://ADRES_IP_DEBIANA:8083

Teraz usuń kontener:
sudo docker rm -f devops-nginx-volume
Następnie uruchom go ponownie z tym samym wolumenem:
sudo docker run -d \
--name devops-nginx-volume \
-p 8083:80 \
-v devops_webdata:/usr/share/nginx/html:ro \
nginx:stable-alpine
Po odświeżeniu strony zobaczysz, że dane nadal są dostępne, mimo że poprzedni kontener został usunięty.
Sprawdź informacje o wolumenie. Za pomocą polecenia docker volume inspect można sprawdzić wolumen i wyświetlić jego szczegóły. Polecenie docker volume ls zaś możemy wylistować wszystkie wolumeny.
sudo docker volume inspect devops_webdata

Na zakończenie zatrzymaj kontener:
sudo docker rm -f devops-nginx-volume
Kiedy stosujemy bind mount, a kiedy named volume?
Bind mount czy named volume?
| Bind mount | Named volume |
|---|---|
| Korzysta z wybranego pliku lub katalogu hosta | Docker zarządza miejscem przechowywania |
| Wygodny podczas edycji kodu i konfiguracji | Wygodny do przechowywania danych aplikacji |
| Zależy od ścieżek na maszynie | Odwołujemy się do wolumenu po nazwie |
| Zmiany plików hosta mogą być od razu widoczne w kontenerze | Dane mogą przetrwać usunięcie i ponowne utworzenie kontenera |
W dalszej części kursu wykorzystamy named volumes przy bazie PostgreSQL.
Budowanie własnego obrazu Docker – aplikacja Node.js
Do tej pory pokazywałem podstawy na bazie gotowego obrazu nginx. Teraz zademonstruję Ci jak spakować własną aplikację do obrazu Dockera, żeby uruchamiała się tak samo na każdym komputerze.
Aplikacja będzie bardzo prosta. Po wejściu na jej stronę główną zwróci komunikat:
Hello from Docker!
Dodamy też adres /health, który później przyda się przy automatycznych testach w CI/CD.
Przygotowanie katalogu projektu
Przejdź do:
cd ~/devops-lab/docker/node-app
Utwórz potrzebne pliki:
touch package.json
touch app.js
touch Dockerfile
touch .dockerignore
Plik package.json
Edytuj plik:
nano package.json
Wklej:
{
"name": "devops-lab-node",
"version": "1.0.0",
"private": true,
"scripts": {
"start": "node app.js"
},
"dependencies": {
"express": "5.1.0"
}
}
Plik ten opisuje konfiguracje projektu Node.js. Zawiera nazwę i wersje projektu, a także wskazuję główny plik ze skryptem. W skrócie plik ten mówi między innymi npm-owi jak uruchomić aplikację i jakie biblioteki ma zainstalować. Dzięki temu później w pliku Dockerfile wystarczy, że wpiszemy komendę npm install i npm będział, że ma zainstalować expressa.
Plik app.js
nano app.js
Wklej:
const express = require("express");
const app = express();
const port = process.env.PORT || 3000;
app.get("/", (req, res) => {
res.send("Hello from Docker!");
});
app.get("/health", (req, res) => {
res.json({ status: "ok" });
});
app.listen(port, "0.0.0.0", () => {
console.log(`App listening on port ${port}`);
});
Kolejnym plikiem, który warto utworzyć jest app.js. W pliku tym będzie znajdował się kod aplikacji uruchamianej w kontenerze. Nie wchodząc w szczegóły programowania jest to prosty serwer HTTP z Node.js z użyciem Expressa. Kod ten sprawi, że gdy ktoś wejdzie na hoście na adres serwera z portem 3000, wówczas dostanie odpowiedź “Hello from Docker!”.
Pod adresem /health aplikacja zwróci prostą odpowiedź JSON:
{
"status": "ok"
}
Ten drugi adres wykorzystamy w przyszłym pipeline CI/CD do sprawdzania, czy aplikacja odpowiada.
Tworzenie package-lock.json bez instalowania Node.js na Debianie
Chcemy zapisać dokładne wersje zależności w pliku package-lock.json.
Przyda się to zarówno przy ponownym budowaniu obrazu, jak i później podczas uruchamiania testów w GitHub Actions.
Możemy wygenerować go przy użyciu tymczasowego kontenera Node.js:
sudo docker run --rm \
--user "$(id -u):$(id -g)" \
-e npm_config_cache=/tmp/npm-cache \
--mount type=bind,source="$(pwd)",target=/app \
-w /app \
node:24-alpine \
npm install --package-lock-only --ignore-scripts --no-audit --no-fund
To dłuższe polecenie, ale nie trzeba zapamiętywać go w całości.
Uruchamiamy tymczasowy kontener z Node.js, podłączamy katalog projektu i wykonujemy npm install --package-lock-only.
Sprawdź:
ls -l package-lock.json
Plik powinien istnieć w katalogu projektu.
Nie musimy instalować Node.js w systemie Debian, żeby przygotować jego zależności.
Dockerfile
Teraz przygotujemy najważniejszy plik. Jak wspominałem w części teoretycznej jest to skrypt będący instrukcją dotyczącą tworzenia obrazu Dockera.
nano Dockerfile
Wklej:
FROM node:24-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev
COPY app.js ./
USER node
EXPOSE 3000
CMD ["npm", "start"]
Co dzieje się podczas budowania?
FROM node:24-alpinewskazuje obraz bazowy z Node.js.WORKDIR /appustawia katalog roboczy.COPY package*.json ./kopiuje pliki opisujące zależności.RUN npm ci --omit=devinstaluje zależności zgodnie z plikiempackage-lock.json, pomijając zależności przeznaczone wyłącznie do developmentu.COPY app.js ./kopiuje kod aplikacji.USER nodeuruchamia późniejsze polecenia w kontekście użytkownikanode, zamiast domyślnego roota.EXPOSE 3000dokumentuje port używany przez aplikację. SamoEXPOSEnie publikuje portu na Debianie.CMD ["npm", "start"]określa polecenie uruchamiane przy starcie kontenera.
Plik .dockerignore
Ostatnim plikiem w projekcie jest plik .dockerignore. Mówi Dockerowi, których plików/katalogów nie kopiować do obrazu podczas docker build. Dzięki temu build obraziu trwa szybciej. Nie wszystkie pliki znajdują się w projekcie, wypisałem je jednak aby pokazać Ci, które pliki mogą znaleźć się w dockerignore. Plik .env często zawiera sekrety/zmienne środowiskowe, bezpieczniej jest nie kopiować go do obrazu.
nano .dockerignore
Dodaj:
node_modules
npm-debug.log
.env
.git
Dzięki temu Docker pominie te pliki i katalogi podczas przygotowywania kontekstu budowania.
Warto od razu rozróżnić dwie rzeczy
.gitignoremówi Gitowi, których plików nie powinien śledzić..dockerignorewskazuje, co Docker powinien pominąć podczas budowania obrazu.
Pliki mają podobną nazwę, ale odpowiadają za różne operacje.
Budowanie obrazu
Znajdujemy się w katalogu:
~/devops-lab/docker/node-app
Uruchom:
sudo docker build -t devops-node-app:1.0 .
Parametr -t nadaje obrazowi nazwę i tag. Kropka na końcu oznacza bieżący katalog, czyli kontekst budowania.
Podczas pierwszego uruchomienia Docker pobierze obraz bazowy i zainstaluje zależności. Może to potrwać dłużej niż kolejne budowania.
Po zakończeniu sprawdź obrazy:
sudo docker image ls
Powinien pojawić się obraz:
devops-node-app 1.0
Uruchomienie aplikacji
Utwórz kontener:
sudo docker run -d \
--name devops-node \
-p 4000:3000 \
devops-node-app:1.0
Port 4000 jest dostępny na Debianie, a 3000 to port aplikacji wewnątrz kontenera.
Sprawdź:
sudo docker ps
Otwórz aplikacje w przeglądarce, powinieneś zobaczyć napis “Hello from Docker!”
http://ADRES_IP_DEBIANA:4000

Sprawdź też endpoint diagnostyczny:
curl http://localhost:4000/health
W odpowiedzi powinieneś zobaczyć:
{"status":"ok"}
Po zakończeniu testów usuń kontener:
sudo docker rm -f devops-node
Obraz devops-node-app:1.0 pozostanie dostępny lokalnie.
Dlaczego kolejny docker build może być szybszy?
Podczas budowania obrazu Docker korzysta z cache. Jeśli pewien etap budowania i jego zależności nie zmieniły się, Docker może wykorzystać wynik wcześniejszego wykonania.
Dlatego w naszym Dockerfile najpierw kopiujemy:
COPY package*.json ./
RUN npm ci --omit=dev
A dopiero potem:
COPY app.js ./
Załóżmy, że poprawiasz tylko tekst zwracany przez aplikację. Pliki package.json i package-lock.json pozostają bez zmian, więc Docker może wykorzystać zapamiętany etap instalowania zależności. Nie musi za każdym razem pobierać wszystkich pakietów.
Gdybyśmy najpierw kopiowali cały projekt, każda zmiana w kodzie mogłaby unieważniać cache dla późniejszej instalacji zależności. To niewielka różnica w Dockerfile, ale przy większych aplikacjach potrafi oszczędzić sporo czasu.
Docker Compose – uruchamianie kilku usług
W realnych projektach aplikacja rzadko działa sama. Najczęściej potrzebujesz też bazy danych (Postgres/MySQL), cache (Redis) lub gotowej aplikacji (Nextcloud) . Docker Compose działa w oparciu o zestaw deklaracji zapisanych w jednym pliku konfiguracyjnym – najczęściej compose.yaml. Ten plik w formacie YAML opisuje cały „stos” aplikacji jakie mają powstać, jak mają się ze sobą komunikować, jakie porty wystawić i gdzie trzymać dane.
Największa zaleta? Zamiast odpalać kilka długich komend docker run i pilnować kolejności uruchamiania, wystarczy jedna:
docker compose up
Compose zrobi za nas całą „robotę pod maską”: utworzy sieć, uruchomi kontenery, podepnie woluminy, ustawi zmienne środowiskowe i resztę konfiguracji. Dzięki temu nie trzeba kleić własnych skryptów w Bashu ani pamiętać dziesiątek parametrów.
Zademonstruję działanie Compose na przykładzie aplikacji Nextcloud. To jeden z najprostszych, a jednocześnie bardzo praktycznych przykładów użycia Docker Compose: uruchamiamy Nextcloud (web) oraz PostgreSQL (baza danych) jako dwa serwisy.
Przygotowanie katalogu
Wróć do głównego katalogu projektu:
cd ~/devops-lab
Następnie przejdź do:
cd docker/nextcloud
Przygotuj pliki:
touch compose.yaml
touch .env.example
- W
compose.yamlzapiszemy konfigurację kontenerów. - W
.env.exampleumieścimy wzór konfiguracji, który będzie można bezpiecznie dodać do repozytorium.
Prawdziwe hasło do lokalnej bazy znajdzie się w oddzielnym pliku .env, którego nie wyślemy do Git.
Konfiguracja compose.yaml
Otwórz:
nano compose.yaml
Wklej:
services:
db:
image: postgres:16-alpine
restart: unless-stopped
environment:
POSTGRES_DB: nextcloud
POSTGRES_USER: nextcloud
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Ustaw haslo w pliku .env}
volumes:
- db_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U nextcloud -d nextcloud"]
interval: 10s
timeout: 5s
retries: 10
nc:
image: nextcloud:apache
restart: unless-stopped
ports:
- "8082:80"
environment:
POSTGRES_HOST: db
POSTGRES_DB: nextcloud
POSTGRES_USER: nextcloud
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Ustaw haslo w pliku .env}
NEXTCLOUD_TRUSTED_DOMAINS: ${NEXTCLOUD_TRUSTED_DOMAINS:-localhost}
depends_on:
db:
condition: service_healthy
volumes:
- nc_data:/var/www/html
volumes:
db_data:
nc_data:
W pliku znajdują się dwa serwisy: db i nc.
- Serwis
dburuchomi PostgreSQL. Korzystamy z obrazupostgres:16-alpinei zapisujemy dane bazy w named volumedb_data. - Serwis
ncuruchomi Nextcloud z Apache. Udostępnimy go na porcie8082Debiana i wykorzystamy drugi wolumen,nc_data.
Połączenie z bazą odbywa się przez nazwę serwisu db. Nie musimy znać adresu IP kontenera PostgreSQL. Docker Compose utworzy sieć, w której serwisy będą mogły komunikować się po nazwach.
Co oznacza depends_on?
W konfiguracji Nextcloud znajduje się:
depends_on:
db:
condition: service_healthy
Ten zapis mówi Compose, żeby poczekał na pozytywny wynik testu zdrowia bazy danych, zanim uruchomi zależny serwis.
To nieco więcej niż zwykła kolejność uruchamiania kontenerów.
Sam zapis:
depends_on:
- db
określa zależność między usługami, ale nie gwarantuje, że PostgreSQL jest już gotowy do przyjmowania połączeń.
Dlatego dodaliśmy healthcheck wykorzystujący pg_isready.
Nie rozwiązuje to wszystkich możliwych problemów przy starcie aplikacji, ale ogranicza częsty przypadek, w którym Nextcloud uruchamia się wcześniej niż gotowa baza.
Plik .env i hasło bazy danych
Otwórz:
nano .env.example
Dodaj:
POSTGRES_PASSWORD=WPISZ_WLASNE_HASLO
NEXTCLOUD_TRUSTED_DOMAINS=localhost
Skopiuj przykładowy plik:
cp .env.example .env
Otwórz:
nano .env
Zamień WPISZ_WLASNE_HASLO na własne hasło przeznaczone wyłącznie do tego laboratorium.
Jeśli będziesz otwierać Nextcloud z komputera przez adres IP Debiana, ustaw również:
NEXTCLOUD_TRUSTED_DOMAINS=192.168.1.100
Podany adres jest przykładem. Wpisz rzeczywisty adres swojej maszyny wirtualnej.
Plik .env nie powinien trafić do repozytorium Git.
Za chwilę dodamy odpowiednią regułę do .gitignore.
Trzymanie hasła w lokalnym pliku .env jest wygodniejsze niż wpisywanie go w wersjonowany compose.yaml, ale nie stanowi pełnego systemu ochrony sekretów. W środowisku produkcyjnym należałoby zastosować odpowiedni mechanizm zarządzania sekretami.
Sprawdzenie konfiguracji Compose
Przed uruchomieniem aplikacji sprawdź składnię:
sudo docker compose config --quiet
Jeżeli konfiguracja jest poprawna, polecenie powinno zakończyć się bez wyświetlania błędu.
Teraz uruchom usługi:
sudo docker compose up -d
Docker pobierze potrzebne obrazy, przygotuje sieć i wolumeny, a następnie uruchomi kontenery. Pierwszy start może potrwać dłużej, szczególnie jeśli obrazy nie znajdują się jeszcze lokalnie. Po zakończeniu sprawdź czy kontenery wystartowały:
sudo docker compose ps
Powinieneś zobaczyć usługi db oraz nc.

Pierwsze uruchomienie Nextcloud
Otwórz w przeglądarce:
http://ADRES_IP_DEBIANA:8082
Przy pierwszym uruchomieniu Nextcloud powinien wyświetlić kreator instalacji. Jeśli wszystko poszło sprawnie to dane zostaną automatycznie podstawione, jeśli nie to podaj dane zgodne z compose.yaml.
Typ bazy: PostgreSQL
Host: db
Nazwa bazy: nextcloud
Użytkownik: nextcloud
Hasło: wartość POSTGRES_PASSWORD z .env

Zatrzymanie aplikacji
Jeżeli chcesz zatrzymać cały zestaw usług:
sudo docker compose down
Compose zatrzyma i usunie utworzone kontenery oraz sieć projektu. Named volumes pozostaną dostępne.
Jeśli później wykonasz:
sudo docker compose up -d
usługi będą mogły ponownie korzystać z zapisanych danych.
Zapisujemy laboratorium Dockera w Git
Mamy już pliki strony Nginx, aplikację Node.js, Dockerfile oraz konfigurację Nextcloud.
Dotychczas pracowaliśmy na gałęzi:
feature/docker-lab
Teraz wykorzystamy umiejętności z poprzedniego modułu kursu.
Wróć do repozytorium:
cd ~/devops-lab-pr
Sprawdź:
git status
Powinieneś zobaczyć nowe pliki w katalogu docker.

Dodanie .gitignore
Otwórz istniejący plik .gitignore w głównym katalogu repozytorium. Jeśli go nie ma, utwórz go.
Dodaj regułę:
docker/nextcloud/.env
Możesz zrobić to również poleceniem:
printf '\ndocker/nextcloud/.env\n' >> .gitignore
Sprawdź, czy Git ignoruje lokalny plik z hasłem:
git check-ignore -v docker/nextcloud/.env
Powinieneś zobaczyć informację o regule odpowiedzialnej za pomijanie tego pliku.

Dzięki temu do repozytorium wyślemy compose.yaml i .env.example, ale nie lokalne hasło.
Przygotowanie zmian do commita
Dodaj pliki z ćwiczeń:
git add .gitignore docker/
Sprawdź, co trafiło do staging area:
git diff --staged --stat

Na liście przygotowanych zmian nie powinno być docker/nextcloud/.env.
Możesz teraz zapisać commit:
git commit -m "Add Docker labs with Nginx Node and Compose"
Wyślij gałąź na GitHuba:
git push -u origin feature/docker-lab
Pull Request na GitHubie
Otwórz swoje repozytorium na GitHubie. Po opublikowaniu brancha powinieneś zobaczyć możliwość utworzenia Pull Requesta.
Wybierz:
base: master
compare: feature/docker-lab
Przykładowy tytuł:
Add Docker laboratory examples
W opisie możesz umieścić:
What:
- Add Nginx bind mount example
- Add Node.js application and Dockerfile
- Add Nextcloud and PostgreSQL Compose configuration
Why:
- Extend the existing DevOps lab with Docker exercises
Testing:
- Run Nginx containers and verify port mappings
- Build and run Node.js application
- Check /health endpoint
- Start Nextcloud with Docker Compose
Przejrzyj zakładkę Files changed. Zwróć szczególną uwagę na to, czy do Pull Requesta nie trafiły żadne hasła, tokeny ani pliki zawierające dane lokalnego środowiska.

Po sprawdzeniu zmian możesz połączyć Pull Request z master. Następnie na Debianie wykonaj:
git switch master
git pull
Jeśli merge zakończył się poprawnie, usuń lokalną gałąź:
git branch -d feature/docker-lab
Na koniec sprawdź:
git status
Tym razem nie zapisaliśmy w Git wyłącznie skryptów Bash. Mamy też aplikację, Dockerfile oraz konfigurację środowiska wielokontenerowego. To przygotuje nas do automatyzacji budowania obrazu.
Następny krok: Mamy już aplikację Node.js oraz Dockerfile zapisane na GitHubie. W kolejnej lekcji zajmiemy się GitHub Actions. Przygotujemy pierwszy workflow CI/CD, który uruchomi się po zmianach w repozytorium, sprawdzi aplikację i automatycznie zbuduje jej obraz Docker.
Przejdź do następnej lekcji: GitHub Actions od podstaw – pierwszy pipeline CI/CD dla aplikacji Docker (w przygotowaniu) →
← Poprzednia lekcja: Docker dla początkujących – jak rozwiązuje problem „u mnie działa”? · Wróć do spisu kursu DevOps