Jak używać Docker dla początkujących: Praktyczny przewodnik

Docker dla początkujących: praktyczny przewodnik po konteneryzacji

Docker dla początkujących: praktyczny przewodnik po konteneryzacji

Przez długie lata fraza „na mojej maszynie wszystko działa” była przekleństwem tworzenia oprogramowania. Jeśli jesteś programistą, administratorem systemów lub specjalistą IT, który chce zrozumieć, jak używać Dockera dla początkujących, trafiłeś we właściwe miejsce. Docker rozwiązuje ten problem, oferując potężne, lekkie rozwiązanie do pakowania i uruchamiania aplikacji w izolowanych środowiskach, zwanych kontenerami, zapewniając ich stabilne działanie wszędzie – od twojego laptopa po chmurę.

Czego się nauczysz

Pod koniec tego przewodnika zrozumiesz podstawowe koncepcje Dockera, uruchomisz swój pierwszy kontener, stworzysz własny obraz i nauczysz się zarządzać aplikacjami wielokontenerowymi za pomocą Docker Compose. Otrzymasz jasny, powtarzalny proces konteneryzacji własnych aplikacji, co pozwoli ci zoptymalizować przepływy pracy związane z tworzeniem i wdrażaniem.

Czym jest Docker i dlaczego jest ważny?

Docker to otwarta platforma zaprojektowana w celu uproszczenia procesu budowania, dostarczania i uruchamiania aplikacji. Osiąga to, umożliwiając oddzielenie aplikacji od infrastruktury, traktując twoje oprogramowanie i jego zależności jako jeden przenośny blok.

Wyobraź sobie Dockera jako system kontenerów dla oprogramowania. Tak jak fizyczny kontener może przewozić dowolny ładunek i być transportowany statkiem, pociągiem lub ciężarówką, tak kontener Docker może zawierać dowolną aplikację z jej zależnościami i działać stabilnie w każdym systemie, w którym zainstalowano Dockera. Ta standaryzacja uczyniła Dockera de facto standardem zarządzania aplikacjami chmurowymi: jego publiczny rejestr Docker Hub zawiera ponad 14 milionów obrazów aplikacji i obsługuje ponad 11 miliardów pobrań obrazów miesięcznie.

Kluczowe zalety używania Dockera

• Przenośność i spójność: Kontenery działają na każdej maszynie z Dockerem (Linux, Windows, macOS) i eliminują błędy związane ze środowiskiem.
• Lekkość i szybkość: W przeciwieństwie do tradycyjnych maszyn wirtualnych (VM), kontenery wykorzystują jądro systemu operacyjnego hosta, co czyni je znacznie mniejszymi (megabajty w porównaniu do gigabajtów) i pozwala uruchamiać się w milisekundach.
• Izolacja i wydajność: Kontenery są odizolowane od siebie i od systemu hosta, co zwiększa bezpieczeństwo i pozwala uruchamiać wiele aplikacji bez konfliktów.
• DevOps i CI/CD: Kontenery są podstawą nowoczesnych potoków CI/CD, zapewniając szybkie testowanie i wdrażanie.

Zrozumienie podstawowych koncepcji: obrazy i kontenery

Zanim zagłębisz się w temat, ważne jest, aby zrozumieć relację między obrazem a kontenerem. To dwie najbardziej fundamentalne koncepcje w Dockerze.

• Obraz Dockera: Obraz to lekki, samodzielny, wykonywalny pakiet oprogramowania, który zawiera wszystko, co niezbędne do uruchomienia oprogramowania: kod, środowisko wykonawcze, narzędzia systemowe, biblioteki i ustawienia. To szablon tylko do odczytu, podobny do migawki lub planu. Na przykład nginx:alpine to wstępnie zbudowany obraz dla serwera WWW NGINX.
• Kontener Dockera: Kontener to uruchomiona instancja obrazu. Możesz tworzyć, uruchamiać, zatrzymywać, przenosić lub usuwać kontener za pomocą API lub CLI Dockera. To obraz „działający” w twoim systemie.

Twoje pierwsze kroki z Dockerem

1. Instalacja Dockera

Na początek musisz zainstalować Dockera. Najprostszym sposobem na zrobienie tego w systemie Windows lub macOS jest pobranie i zainstalowanie Docker Desktop z oficjalnej strony Dockera. Zawiera on wszystko, czego potrzebujesz: silnik Dockera, CLI i Compose. Dla użytkowników Linuxa możesz zainstalować silnik Dockera za pomocą menedżera pakietów swojej dystrybucji.

Po instalacji otwórz terminal lub wiersz poleceń i sprawdź instalację:

docker --version

2. Uruchomienie twojego pierwszego kontenera

Uruchommy kontener „Hello World”, aby upewnić się, że wszystko działa. To tradycyjny pierwszy krok do zrozumienia, jak używać Dockera dla początkujących.

docker run hello-world

To polecenie robi kilka rzeczy: sprawdza, czy obraz hello-world istnieje lokalnie, pobiera go z Docker Hub, jeśli nie, a następnie tworzy i uruchamia kontener z tego obrazu. Kontener wyświetla komunikat powitalny i kończy działanie. Ten przepływ – sprawdzenie lokalnie, pobranie z rejestru, a następnie uruchomienie – jest podstawą pracy z Dockerem.

3. Uruchomienie prawdziwego serwera WWW

Uczyńmy zadanie bardziej interesującym, uruchamiając prawdziwy serwer WWW NGINX w tle. To polecenie wprowadza trzy ważne flagi:

docker run -d -p 8080:80 --name mywebserver nginx

• -d (Detached): Uruchamia kontener w tle.
• -p 8080:80 (Publish): Mapuje port 8080 na twojej maszynie hosta na port 80 wewnątrz kontenera. Teraz możesz uzyskać dostęp do serwera WWW pod adresem http://localhost:8080.
• --name mywebserver: Nadaje kontenerowi zrozumiałą nazwę zamiast losowego identyfikatora.

Teraz otwórz przeglądarkę i przejdź do http://localhost:8080. Powinieneś zobaczyć stronę powitalną NGINX! To dowodzi, że prawdziwy serwer WWW działa, jest izolowany w kontenerze i dostępny na twojej maszynie.

Tworzenie własnego obrazu Dockera

Chociaż uruchamianie gotowych obrazów jest przydatne, prawdziwa siła Dockera leży w pakowaniu własnych aplikacji. Robi się to za pomocą Dockerfile.

Czym jest Dockerfile?

Dockerfile to prosty plik tekstowy zawierający zestaw instrukcji lub poleceń dotyczących tego, jak zbudować obraz Dockera. Działa jak przepis na stworzenie przenośnego, samowystarczalnego środowiska dla twojej aplikacji.

Tworzenie prostej aplikacji Node.js

Stwórzmy prosty Dockerfile do konteneryzacji aplikacji Node.js. To da ci praktyczny szablon, który można dostosować do wielu projektów.

1. Utwórz folder projektu:

   mkdir my-node-app && cd my-node-app

2. Utwórz prostą aplikację: Utwórz plik o nazwie app.js.

   const http = require('http');
   
   const server = http.createServer((req, res) => {
     res.writeHead(200, { 'Content-Type': 'text/plain' });
     res.end('Hello, World! My app is running in a container!\n');
   });
   
   server.listen(3000, () => {
     console.log('Server running at http://localhost:3000/');
   });

3. Utwórz package.json: Utwórz plik o nazwie package.json, aby zadeklarować zależności aplikacji.

   {
     "name": "my-node-app",
     "version": "1.0.0",
     "main": "app.js"
   }

Pisanie Dockerfile

Teraz utwórz plik o nazwie Dockerfile (bez rozszerzenia) w tym samym katalogu z następującą treścią:

FROM node:18-alpine
WORKDIR /app
COPY package.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "app.js"]

Omówmy każde polecenie:

• FROM node:18-alpine: Inicjuje budowę z obrazu bazowego. Używamy oficjalnego obrazu Node.js w wersji 18 opartego na Alpine Linux – bardzo małej dystrybucji Linuxa, co czyni nasz obraz znacznie lżejszym.
• WORKDIR /app: Ustawia katalog roboczy dla wszystkich kolejnych instrukcji RUN, CMD, COPY i ADD. Jeśli katalog nie istnieje, zostanie utworzony.
• COPY package.json ./: Kopiuje plik package.json z twojego lokalnego katalogu do bieżącego katalogu roboczego wewnątrz obrazu.
• RUN npm install: Wykonuje polecenie npm install wewnątrz kontenera, aby zainstalować wszystkie zależności zdefiniowane w package.json.
• COPY . .: Kopiuje resztę kodu źródłowego twojej aplikacji z lokalnego katalogu do katalogu roboczego wewnątrz obrazu.
• EXPOSE 3000: Informuje Dockera, że kontener nasłuchuje na porcie 3000 podczas działania.
• CMD ["node", "app.js"]: Określa polecenie, które zostanie wykonane podczas uruchamiania kontenera z tego obrazu.

Budowanie i uruchamianie twojego obrazu

1. Zbuduj obraz: W terminalu wykonaj polecenie docker build:

   docker build -t my-node-app:1.0 .

   • -t my-node-app:1.0: Nadaje twojemu obrazowi nazwę i wersję.
   • .: Wskazuje Dockerowi, aby szukał Dockerfile w bieżącym katalogu.

2. Uruchom kontener: Teraz uruchom swój nowy obraz, mapując port hosta na port kontenera:

   docker run -d -p 3000:3000 --name my-running-app my-node-app:1.0

Przejdź w przeglądarce do http://localhost:3000, a powinieneś zobaczyć komunikat „Hello, World!”. Gratulacje, pomyślnie utworzyłeś i uruchomiłeś własny obraz Dockera!

Zarządzanie aplikacjami wielokontenerowymi za pomocą Docker Compose

Nowoczesne aplikacje rzadko składają się z pojedynczej usługi; często obejmują interfejs WWW, bazę danych, pamięć podręczną i wiele innych. Zarządzanie nimi za pomocą wielu poleceń docker run może być uciążliwe. Docker Compose to narzędzie, które pozwala definiować i uruchamiać aplikacje wielokontenerowe w jednym pliku compose.yaml (lub docker-compose.yml).

Przykład: aplikacja WWW z Redis

Oto przykład pliku compose.yaml, który definiuje usługę WWW i usługę pamięci podręcznej Redis:

services:
  web:
    image: nginx:alpine
    ports:
      - "8082:80"
  cache:
    image: redis:alpine

Ten plik definiuje dwie usługi:

• web: Używa oficjalnego obrazu nginx:alpine i mapuje port 8082 na hoście na port 80 wewnątrz kontenera.
• cache: Używa oficjalnego obrazu redis:alpine.

Aby uruchomić obie usługi, po prostu użyj następujących poleceń:

docker compose up -d
docker compose ps

To uruchomi oba kontenery razem w dedykowanej sieci, umożliwiając im wzajemną komunikację. Możesz zatrzymać i usunąć wszystko za pomocą docker compose down.

Źródła

1. Docker Docs. «Introduction.»
2. Docker Docs. «Overview of the Docker workshop.»
3. Docker Docs. «What is Docker?»
4. Docker Setup for DevOps Beginners (GitHub)
5. KodeKloud. «Docker Tutorial for Beginners in 2026: First Steps.»
6. Microsoft Learn. «When to use Docker containers.»
7. freeCodeCamp. «How to Containerize a Node.js Application Using Docker.»
8. Docker Docs. «Get started.»
9. Communications of the ACM. «A Decade of Docker Containers.»
10. Flatcar. «Getting started with Docker.»
11. Manning Publications. «Learn Docker in a Month of Lunches.»

— Editorial Team