🐳 Jak zainstalować i używać Dockera na Ubuntu 20.04

Docker zrewolucjonizował proces tworzenia, wdrażania i uruchamiania aplikacji dzięki technologii konteneryzacji. W tym przewodniku pokazujemy, jak zainstalować Docker na Ubuntu 20.04, zarządzać kontenerami i obrazami oraz budować własne środowiska deweloperskie. Niezależnie od tego, czy jesteś początkującym programistą czy doświadczonym administratorem, pomoże Ci to wykorzystać pełny potencjał Dockera w codziennej pracy.

⚡ Ekspresowe Podsumowanie:

  1. Instalacja Dockera: Dodaj oficjalne repozytorium, zainstaluj pakiety i skonfiguruj uprawnienia użytkownika.
  2. Podstawy: Naucz się zarządzać kontenerami, obrazami oraz sieciami Docker.
  3. Docker Compose: Używaj Docker Compose do definiowania i uruchamiania aplikacji składających się z wielu kontenerów.
  4. Dobre praktyki: Zabezpiecz swoje kontenery, optymalizuj obrazy i zarządzaj zasobami efektywnie.

🗺️ Spis Treści - Twoja Mapa Drogowa

📚 Co to jest Docker i dlaczego warto go używać?

Docker to platforma open-source, która automatyzuje wdrażanie aplikacji wewnątrz kontenerów. Kontenery pozwalają deweloperom pakować aplikacje ze wszystkimi potrzebnymi częściami, takimi jak biblioteki i inne zależności, oraz wysyłać je jako jeden pakiet.

Kluczowe zalety Dockera:

  • Spójne środowisko - "działa na moim komputerze" nie jest już problemem, gdy używasz Dockera
  • Izolacja - każdy kontener działa niezależnie, co zwiększa bezpieczeństwo i ułatwia zarządzanie
  • Efektywność - kontenery współdzielą jądro systemu operacyjnego, co czyni je lżejszymi niż tradycyjne maszyny wirtualne
  • Skalowalność - łatwe skalowanie aplikacji poprzez tworzenie wielu instancji kontenera
  • Łatwość wdrażania - szybkie i spójne wdrażanie na różnych środowiskach (produkcja, testowe, deweloperskie)

Docker jest szczególnie przydatny dla:

  • Deweloperów pracujących w zespołach na różnych systemach operacyjnych
  • Administratorów systemów poszukujących efektywnego wykorzystania zasobów
  • Wdrażania mikrousług i aplikacji cloudowych
  • Tworzenia powtarzalnych środowisk testowych

Uwaga: Docker używa technologii konteneryzacji, która różni się od tradycyjnej wirtualizacji. Kontenery współdzielą jądro systemu operacyjnego hosta, ale mają izolowane przestrzenie użytkownika i systemu plików.

💻 Instalacja Dockera na Ubuntu 20.04

W tej sekcji przeprowadzimy Cię przez proces instalacji Docker Engine na Ubuntu 20.04 LTS (Focal Fossa).

Wymagania systemowe

Przed rozpoczęciem upewnij się, że Twój system spełnia minimalne wymagania:

  • Ubuntu 20.04 LTS (64-bit)
  • Co najmniej 4GB RAM
  • Dostęp do konta z uprawnieniami sudo
  • Połączenie z internetem

Aktualizacja systemu

Zawsze dobrą praktyką jest aktualizacja systemu przed instalacją nowego oprogramowania:

sudo apt update
sudo apt upgrade -y

Instalacja wymaganych pakietów

Zainstaluj pakiety, które pozwolą na używanie repozytorium przez HTTPS:

sudo apt install -y apt-transport-https ca-certificates curl software-properties-common gnupg lsb-release

Dodanie oficjalnego klucza GPG Dockera

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Dodanie repozytorium Dockera

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Instalacja Docker Engine

Zaktualizuj indeks pakietów i zainstaluj Docker Engine:

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io

Weryfikacja instalacji

Sprawdź, czy Docker został prawidłowo zainstalowany, uruchamiając przykładowy kontener:

sudo docker run hello-world

Powinieneś zobaczyć wiadomość powitalną potwierdzającą, że Docker działa poprawnie.

Konfiguracja uprawnień Docker bez sudo (opcjonalnie)

Domyślnie, Docker wymaga uprawnień administratora (sudo). Aby móc używać Dockera bez sudo, dodaj swojego użytkownika do grupy docker:

sudo usermod -aG docker ${USER}

Następnie, zrestartuj sesję lub użyj:

newgrp docker

Sprawdź, czy możesz uruchamiać Docker bez sudo:

docker run hello-world

✨ Pro Tip: Dodanie użytkownika do grupy docker jest wygodne, ale ma implikacje bezpieczeństwa - każdy z dostępem do tej grupy ma efektywnie uprawnienia roota na maszynie hosta.

Instalacja Docker Compose

Docker Compose to narzędzie do definiowania i uruchamiania aplikacji wielokontenerowych. Aby zainstalować najnowszą wersję:

sudo curl -L "https://github.com/docker/compose/releases/download/v2.24.5/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Sprawdź instalację Docker Compose:

docker-compose --version

🚀 Podstawy Dockera - komendy i koncepcje

W tej sekcji omówimy podstawowe komendy i koncepcje Dockera, które pozwolą Ci rozpocząć pracę z kontenerami.

Zarządzanie obrazami

Obrazy Docker to szablony używane do tworzenia kontenerów.

Pobieranie obrazu:

docker pull ubuntu:20.04

Listowanie dostępnych obrazów:

docker images

Budowanie obrazu z Dockerfile:

docker build -t nazwa_obrazu:tag .

Usuwanie obrazu:

docker rmi nazwa_obrazu:tag

Zarządzanie kontenerami

Kontenery to uruchomione instancje obrazów.

Uruchamianie kontenera:

docker run -d --name moj_kontener ubuntu:20.04

Popularne flagi:

  • -d - uruchom w tle (detached mode)
  • -p 8080:80 - mapowanie portów (port hosta:port kontenera)
  • -v /sciezka/hosta:/sciezka/kontenera - montowanie wolumenu
  • -e NAZWA_ZMIENNEJ=wartość - ustawienie zmiennej środowiskowej
  • --name nazwa_kontenera - nadanie nazwy kontenerowi

Listowanie działających kontenerów:

docker ps

Listowanie wszystkich kontenerów (również zatrzymanych):

docker ps -a

Zatrzymywanie kontenera:

docker stop nazwa_kontenera

Uruchamianie zatrzymanego kontenera:

docker start nazwa_kontenera

Usuwanie kontenera:

docker rm nazwa_kontenera

Wyświetlanie logów kontenera:

docker logs nazwa_kontenera

Wykonanie komendy w działającym kontenerze:

docker exec -it nazwa_kontenera bash

Sieć Docker

Kontenery mogą komunikować się ze sobą poprzez sieci Docker.

Tworzenie sieci:

docker network create moja_siec

Listowanie sieci:

docker network ls

Uruchamianie kontenera w określonej sieci:

docker run -d --network moja_siec --name moj_kontener ubuntu:20.04

Inspekcja sieci:

docker network inspect moja_siec

Wolumeny Docker

Wolumeny pozwalają na trwałe przechowywanie danych generowanych i używanych przez kontenery.

Tworzenie wolumenu:

docker volume create moj_wolumen

Listowanie wolumenów:

docker volume ls

Uruchamianie kontenera z wolumenem:

docker run -d -v moj_wolumen:/dane --name moj_kontener ubuntu:20.04

Usuwanie wolumenu:

docker volume rm moj_wolumen

Uwaga: Dane w wolumenach Docker przetrwają, nawet jeśli kontener zostanie usunięty. Jest to ważne dla aplikacji, które muszą przechowywać dane pomiędzy restartami kontenerów.

🛠️ Tworzenie i konfiguracja kontenerów

Docker jest potężnym narzędziem, ale jego prawdziwa moc ujawnia się, gdy zaczynasz tworzyć własne niestandardowe obrazy i konfiguracje.

Tworzenie Dockerfile

Dockerfile to skrypt zawierający instrukcje do budowania obrazu Docker. Oto podstawowy przykład Dockerfile dla aplikacji Node.js:

# Bazuj na obrazie Node.js
FROM node:14

# Ustaw katalog roboczy
WORKDIR /app

# Kopiuj pliki package.json i package-lock.json
COPY package*.json ./

# Instaluj zależności
RUN npm install

# Kopiuj resztę kodu aplikacji
COPY . .

# Otwórz port 3000
EXPOSE 3000

# Komenda uruchamiająca aplikację
CMD ["node", "app.js"]

Główne instrukcje w Dockerfile:

  • FROM - określa obraz bazowy
  • WORKDIR - ustawia katalog roboczy w kontenerze
  • COPY - kopiuje pliki z hosta do kontenera
  • RUN - wykonuje komendy podczas budowania obrazu
  • EXPOSE - informuje Dockera, że kontener nasłuchuje na określonym porcie
  • CMD - domyślna komenda uruchamiana przy starcie kontenera
  • ENV - ustawia zmienne środowiskowe

Budowanie obrazu

Aby zbudować obraz z Dockerfile:

docker build -t moja_aplikacja:1.0 .

Gdzie:

  • -t moja_aplikacja:1.0 określa nazwę i tag obrazu
  • . oznacza, że Dockerfile znajduje się w bieżącym katalogu

Warstwy obrazów Docker

Każda instrukcja w Dockerfile tworzy nową warstwę w obrazie. Warstwy są buforowane i ponownie używane, co przyspiesza proces budowania.

✨ Pro Tip: Umieszczaj instrukcje, które rzadko się zmieniają (np. instalacja zależności) na początku Dockerfile, a te, które zmieniają się często (np. kopiowanie kodu aplikacji) - później. Dzięki temu wykorzystasz buforowanie warstw.

Typowe wzorce konteneryzacji

  1. Jeden proces na kontener - najlepsza praktyka to uruchamianie jednego procesu w kontenerze
  2. Niezmienność - traktuj kontenery jako niezmienne; zamiast modyfikować, twórz nowe
  3. Lekkie obrazy - używaj bazowych obrazów typu Alpine dla mniejszego rozmiaru
  4. Zmienne środowiskowe - używaj ich do konfiguracji kontenerów
  5. Wolumeny - używaj ich do trwałego przechowywania danych

📦 Docker Compose - zarządzanie wielokontenerowymi aplikacjami

Docker Compose to narzędzie, które pozwala definiować i uruchamiać wielokontenerowe aplikacje Docker. Używa pliku YAML do konfiguracji usług, sieci i wolumenów.

Przykładowy plik docker-compose.yml

Poniżej znajduje się przykład pliku docker-compose.yml dla prostej aplikacji webowej z bazą danych:

version: '3'

services:
  web:
    build: ./app
    ports:
      - "8000:5000"
    volumes:
      - ./app:/app
    environment:
      - DATABASE_URL=mysql://user:password@db:3306/dbname
    depends_on:
      - db

  db:
    image: mysql:5.7
    volumes:
      - db_data:/var/lib/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=rootpassword
      - MYSQL_DATABASE=dbname
      - MYSQL_USER=user
      - MYSQL_PASSWORD=password
    ports:
      - "3306:3306"

volumes:
  db_data:

Podstawowe komendy Docker Compose

Uruchamianie aplikacji:

docker-compose up

Uruchamianie w tle:

docker-compose up -d

Zatrzymywanie aplikacji:

docker-compose down

Zatrzymywanie i usuwanie wolumenów:

docker-compose down -v

Wyświetlanie logów:

docker-compose logs

Przebudowanie kontenerów:

docker-compose build

Uruchomienie określonej usługi:

docker-compose up -d nazwa_uslugi

Wykonanie komendy w kontenerze usługi:

docker-compose exec nazwa_uslugi komenda

Użycie zmiennych środowiskowych

Możesz używać pliku .env z Docker Compose:

# .env
MYSQL_ROOT_PASSWORD=tajnehaslo
EXTERNAL_PORT=8080

I odwoływać się do zmiennych w docker-compose.yml:

services:
  web:
    ports:
      - "${EXTERNAL_PORT}:5000"

✨ Pro Tip: Docker Compose jest idealny do środowisk deweloperskich i testowych. W produkcji rozważ użycie Kubernetes lub Docker Swarm dla lepszego zarządzania i skalowalności.

🔐 Bezpieczeństwo i dobre praktyki

Bezpieczne korzystanie z Dockera wymaga świadomości potencjalnych zagrożeń i stosowania dobrych praktyk.

Zabezpieczanie kontenerów

  1. Nie uruchamiaj procesów jako root:

    # Utwórz użytkownika i grupę
RUN groupadd -r appuser && useradd -r -g appuser appuser
# Zmień właściciela plików aplikacji
RUN chown -R appuser:appuser /app
# Przełącz na użytkownika nieprzywilej.
USER appuser

  2. Skanuj obrazy w poszukiwaniu luk bezpieczeństwa:

    # Przykład użycia narzędzia Trivy
trivy image nazwa_obrazu:tag

  3. Ogranicz zasoby kontenerów:

    docker run -d --name moj_kontener \
  --memory="512m" \
  --cpus="0.5" \
  ubuntu:20.04

  4. Używaj tajemnic (secrets) dla wrażliwych danych:

    # Tworzenie tajemnicy
echo "moje_tajne_haslo" | docker secret create moja_tajemnica -

# Używanie w docker-compose.yml
secrets:
  - moja_tajemnica

Optymalizacja obrazów Docker

  1. Używaj lekkich obrazów bazowych:

    # Zamiast
FROM ubuntu:20.04

# Użyj
FROM alpine:3.14

  2. Łącz polecenia RUN, aby zmniejszyć liczbę warstw:

    # Zamiast
RUN apt-get update
RUN apt-get install -y package1
RUN apt-get install -y package2

# Użyj
RUN apt-get update && apt-get install -y \
    package1 \
    package2 \
    && rm -rf /var/lib/apt/lists/*

  3. Używaj .dockerignore: Utwórz plik .dockerignore podobny do .gitignore, aby wykluczyć niepotrzebne pliki z kontekstu budowania:

    node_modules
npm-debug.log
.git
.env

  4. Wieloetapowe budowanie dla mniejszych obrazów:

    # Etap budowania
FROM node:14 AS build
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Etap produkcyjny
FROM nginx:alpine
COPY --from=build /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Monitorowanie i zarządzanie kontenerami

  1. Sprawdzanie użycia zasobów:

    docker stats

  2. Czyszczenie nieużywanych zasobów:

    # Usuwanie zatrzymanych kontenerów, nieużywanych sieci i niezgłoszonych obrazów
docker system prune

# Dodanie nieużywanych wolumenów do czyszczenia
docker system prune --volumes

  3. Ustawienie automatycznego restartu kontenerów:

    docker run -d --restart=always --name moj_kontener ubuntu:20.04

    Opcje restart:

    • no - nie restartuj automatycznie (domyślnie)
    • on-failure - restartuj tylko w przypadku błędu
    • always - zawsze restartuj
    • unless-stopped - zawsze restartuj, chyba że został ręcznie zatrzymany

🌐 Praktyczne przykłady zastosowań Dockera

W tej sekcji przedstawimy praktyczne przykłady użycia Dockera w różnych scenariuszach.

Konfiguracja WordPress z MySQL

# docker-compose.yml
version: '3'

services:
  wordpress:
    image: wordpress:latest
    ports:
      - "8080:80"
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - wordpress_data:/var/www/html
    depends_on:
      - db

  db:
    image: mysql:5.7
    volumes:
      - db_data:/var/lib/mysql
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: wordpress

volumes:
  wordpress_data:
  db_data:

Aby uruchomić:

docker-compose up -d

Następnie otwórz przeglądarkę i przejdź pod adres http://localhost:8080 aby dokończyć instalację WordPress.

Środowisko deweloperskie MERN (MongoDB, Express, React, Node.js)

# docker-compose.yml
version: '3'

services:
  frontend:
    build: ./frontend
    ports:
      - "3000:3000"
    volumes:
      - ./frontend:/app
      - /app/node_modules
    environment:
      - REACT_APP_API_URL=http://localhost:5000
    depends_on:
      - backend

  backend:
    build: ./backend
    ports:
      - "5000:5000"
    volumes:
      - ./backend:/app
      - /app/node_modules
    environment:
      - MONGODB_URI=mongodb://db:27017/mernapp
    depends_on:
      - db

  db:
    image: mongo:latest
    ports:
      - "27017:27017"
    volumes:
      - mongo_data:/data/db

volumes:
  mongo_data:

Bazowy serwer proxy Nginx

# docker-compose.yml
version: '3'

services:
  nginx:
    image: nginx:latest
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./html:/usr/share/nginx/html
      - ./certs:/etc/nginx/certs
    restart: always
# nginx.conf
events {
    worker_connections 1024;
}

http {
    server {
        listen 80;
        server_name example.com;

        location / {
            return 301 https://$host$request_uri;
        }
    }

    server {
        listen 443 ssl;
        server_name example.com;

        ssl_certificate /etc/nginx/certs/cert.pem;
        ssl_certificate_key /etc/nginx/certs/key.pem;

        location / {
            root /usr/share/nginx/html;
            index index.html;
        }
    }
}

❓ FAQ - Odpowiedzi na Twoje Pytania

Jak mogę rozwiązać problem z uprawnieniami przy montowaniu wolumenów?
Problem z uprawnieniami często pojawia się, gdy ID użytkownika w kontenerze nie odpowiada ID użytkownika na hoście. Możesz to rozwiązać na kilka sposobów:

  1. Zmień właściciela plików na hoście: sudo chown -R 1000:1000 ./data
  2. Uruchom kontener z tym samym UID co na hoście: docker run -u $(id -u):$(id -g) ...
  3. W Dockerfile, stwórz użytkownika z takim samym UID jak na hoście

Jak zarządzać danymi trwałymi w kontenerach Docker?
Docker oferuje trzy główne opcje przechowywania danych:

  1. Wolumeny (najlepsza opcja): docker volume create moj_wolumen
  2. Montowanie katalogów hosta: docker run -v /sciezka/hosta:/sciezka/kontenera ...
  3. Tmpfs mounts (dane tylko w pamięci): docker run --tmpfs /tmp ...

Jak uzyskać dostęp do kontenera z innego kontenera?
W tej samej sieci Docker, kontenery mogą komunikować się ze sobą używając nazw kontenerów jako nazw hostów. Na przykład, jeśli masz kontener o nazwie "db", inny kontener w tej samej sieci może połączyć się z nim używając "db" jako nazwy hosta.

Jak automatycznie uruchamiać kontenery przy starcie systemu?
Użyj flagi --restart=always przy uruchamianiu kontenera lub restart: always w docker-compose.yml.

Czy mogę używać Dockera bez internetu?
Tak, ale musisz wcześniej pobrać wszystkie potrzebne obrazy. Możesz zapisać obrazy używając docker save i załadować je na innym komputerze używając docker load.

🏁 Podsumowanie - Docker jako fundamentalne narzędzie dewelopera

Docker zrewolucjonizował sposób, w jaki deweloperzy tworzą, testują i wdrażają aplikacje. W tym przewodniku omówiliśmy:

  • Jak zainstalować Docker na Ubuntu 20.04
  • Podstawowe pojęcia i komendy Docker
  • Jak tworzyć własne obrazy za pomocą Dockerfile
  • Zarządzanie wielokontenerowymi aplikacjami za pomocą Docker Compose
  • Dobre praktyki bezpieczeństwa i optymalizacji
  • Praktyczne przykłady zastosowań Dockera

Konteneryzacja to umiejętność, która staje się niezbędna w nowoczesnym rozwoju oprogramowania. Docker umożliwia standaryzację procesów deweloperskich, testowych i produkcyjnych, eliminując problemy związane z różnicami w środowiskach.

Pamiętaj, że Docker to tylko jeden z elementów ekosystemu konteneryzacji - w miarę rozwoju umiejętności, możesz eksplorować zaawansowane narzędzia jak Kubernetes do orkiestracji kontenerów w dużej skali.

🚀 Potrzebujesz hostingu z pełną obsługą Dockera?

Sprawdź ofertę serwerów VPS w IQHost

Nasze serwery VPS oferują wsparcie dla Docker i Docker Compose, a także wysoką wydajność i niezawodność dla Twoich konteneryzowanych aplikacji.

Kategorie i tagi

DevOps Wirtualizacja

Czy ten artykuł był pomocny?

Wróć do listy wpisów

Twoja strona WordPress działa wolno?

Sprawdź nasz hosting WordPress z ultraszybkimi dyskami NVMe i konfiguracją serwera zoptymalizowaną pod kątem wydajności. Doświadcz różnicy już dziś!

Sprawdź ofertę hostingu
30-dniowa gwarancja zwrotu pieniędzy