Docker w praktyce na Debianie

by Patryk

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:

  • run tworzy i uruchamia kontener,
  • -d oznacza pracę w tle,
  • --name web nadaje kontenerowi własną nazwę,
  • nginx:stable-alpine wskazuje 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:

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 mountNamed volume
Korzysta z wybranego pliku lub katalogu hostaDocker zarządza miejscem przechowywania
Wygodny podczas edycji kodu i konfiguracjiWygodny do przechowywania danych aplikacji
Zależy od ścieżek na maszynieOdwołujemy się do wolumenu po nazwie
Zmiany plików hosta mogą być od razu widoczne w kontenerzeDane 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-alpine wskazuje obraz bazowy z Node.js.
  • WORKDIR /app ustawia katalog roboczy.
  • COPY package*.json ./ kopiuje pliki opisujące zależności.
  • RUN npm ci --omit=dev instaluje zależności zgodnie z plikiem package-lock.json, pomijając zależności przeznaczone wyłącznie do developmentu.
  • COPY app.js ./ kopiuje kod aplikacji.
  • USER node uruchamia późniejsze polecenia w kontekście użytkownika node, zamiast domyślnego roota.
  • EXPOSE 3000 dokumentuje port używany przez aplikację. Samo EXPOSE nie 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

  • .gitignore mówi Gitowi, których plików nie powinien śledzić.
  • .dockerignore wskazuje, 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.yaml zapiszemy konfigurację kontenerów.
  • W .env.example umieś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 db uruchomi PostgreSQL. Korzystamy z obrazu postgres:16-alpine i zapisujemy dane bazy w named volume db_data.
  • Serwis nc uruchomi Nextcloud z Apache. Udostępnimy go na porcie 8082 Debiana 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

Może Cię również zainteresować

Dodaj komentarz