Przewodnik wprowadzający do Dockera: Szybkie rozpoczęcie konteneryzacji aplikacji

Docker stał się nieodzowną częścią nowoczesnego tworzenia i wdrażania oprogramowania. Pomimo wszechobecnych dyskusji na temat Kubernetes, Docker pozostaje preferowanym narzędziem dla wielu firm do budowania, testowania i wdrażania aplikacji. Ten artykuł wprowadzi Cię w Dockera, zapozna z jego podstawowymi koncepcjami i dostarczy praktyczny przykład, który pomoże Ci rozpocząć konteneryzację Twojej aplikacji.

Podstawowe koncepcje Dockera

Zanim zaczniesz ćwiczyć, ważne jest, aby zrozumieć kilka podstawowych koncepcji Dockera:

• Obraz (Image): Obraz to szablon tylko do odczytu, który zawiera wszystko, co jest potrzebne do uruchomienia aplikacji: kod, środowisko uruchomieniowe, narzędzia systemowe, biblioteki i zależności. Jest podobny do obrazu maszyny wirtualnej, ale jest lżejszy.

• Kontener (Container): Kontener to działająca instancja utworzona z obrazu. Jest to instancja obrazu w czasie wykonywania, która zawiera aplikację i wszystkie jej zależności. Kontenery są od siebie odizolowane i mają własny system plików, procesy i przestrzeń sieciową.

• Docker Hub: Docker Hub to publiczne repozytorium obrazów, z którego możesz pobierać wstępnie zbudowane obrazy lub przesyłać własne. Jest podobny do GitHub, ale dedykowany obrazom Dockera.

• Dockerfile: Dockerfile to plik tekstowy zawierający wszystkie instrukcje potrzebne do zbudowania obrazu Dockera. Pisząc Dockerfile, możesz zautomatyzować proces tworzenia obrazu.

• Docker Compose: Docker Compose to narzędzie do definiowania i uruchamiania aplikacji Docker składających się z wielu kontenerów. Umożliwia konfigurowanie usług aplikacji za pomocą plików YAML, a następnie uruchamianie lub zatrzymywanie wszystkich usług za pomocą jednego polecenia.

Instalacja Dockera

Najpierw musisz zainstalować Dockera. Docker udostępnia pakiety instalacyjne dla różnych systemów operacyjnych. Odwiedź oficjalną stronę Dockera i postępuj zgodnie z odpowiednimi instrukcjami instalacji.

Po zakończeniu instalacji możesz sprawdzić, czy Docker został poprawnie zainstalowany, uruchamiając polecenie docker --version.

Konteneryzacja prostej aplikacji Python

Utworzymy prostą aplikację Python i użyjemy Dockera do jej konteneryzacji.

1. Utwórz aplikację Python

Utwórz plik o nazwie app.py zawierający następujący kod:

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello, Docker!"

if __name__ == "__main__":
    app.run(debug=True, host='0.0.0.0')

Ta prosta aplikacja Flask zwróci "Hello, Docker!" na ścieżce głównej /.

2. Utwórz plik requirements.txt

Aplikacja zależy od biblioteki Flask, musimy utworzyć plik requirements.txt, aby zadeklarować te zależności.

Flask

3. Utwórz Dockerfile

Utwórz plik o nazwie Dockerfile i dodaj następującą zawartość:

# Użyj oficjalnego obrazu Python jako obrazu bazowego
FROM python:3.9-slim-buster

# Ustaw katalog roboczy
WORKDIR /app

# Skopiuj plik requirements.txt do katalogu roboczego
COPY requirements.txt .

# Zainstaluj zależności
RUN pip install --no-cache-dir -r requirements.txt
```# Kopiowanie kodu aplikacji do katalogu roboczego
COPY app.py .

# Udostępnianie portu 5000
EXPOSE 5000

# Definiowanie polecenia uruchomieniowego
CMD ["python", "app.py"]

Wyjaśnienie Dockerfile:

• FROM python:3.9-slim-buster: Określa obraz bazowy jako odchudzoną wersję Pythona 3.9.
• WORKDIR /app: Ustawia katalog roboczy wewnątrz kontenera na /app.
• COPY requirements.txt .: Kopiuje plik requirements.txt z bieżącego katalogu do katalogu /app w kontenerze.
• RUN pip install --no-cache-dir -r requirements.txt: Uruchamia polecenie pip w kontenerze, aby zainstalować zależności określone w pliku requirements.txt. Parametr --no-cache-dir może zmniejszyć rozmiar obrazu.
• COPY app.py .: Kopiuje plik app.py z bieżącego katalogu do katalogu /app w kontenerze.
• EXPOSE 5000: Deklaruje, że kontener będzie nasłuchiwał na porcie 5000.
• CMD ["python", "app.py"]: Definiuje polecenie wykonywane podczas uruchamiania kontenera.

4. Budowanie obrazu Docker

W katalogu zawierającym Dockerfile uruchom następujące polecenie, aby zbudować obraz Docker:

docker build -t my-python-app .

• docker build: Polecenie budowania obrazu.
• -t my-python-app: Określa nazwę obrazu (my-python-app).
• .: Określa katalog, w którym znajduje się Dockerfile (bieżący katalog).

Proces budowania może zająć trochę czasu, w zależności od szybkości sieci i rozmiaru zależności.

5. Uruchamianie kontenera Docker

Użyj następującego polecenia, aby uruchomić kontener Docker:

docker run -d -p 5000:5000 my-python-app

• docker run: Polecenie uruchamiania kontenera.
• -d: Uruchamia kontener w trybie odłączonym (działa w tle).
• -p 5000:5000: Mapuje port 5000 hosta na port 5000 kontenera.
• my-python-app: Określa nazwę obrazu do użycia.

6. Weryfikacja aplikacji

W przeglądarce przejdź do http://localhost:5000, powinieneś zobaczyć "Hello, Docker!".

7. Zatrzymywanie i usuwanie kontenera

Użyj następującego polecenia, aby zatrzymać kontener:

docker stop 

`` Można sprawdzić za pomocą polecenia docker ps.

Użyj następującego polecenia, aby usunąć kontener:

docker rm 

Wprowadzenie do Docker Compose

Jeśli twoja aplikacja składa się z wielu usług, możesz użyć Docker Compose do zarządzania nimi.

1. Tworzenie pliku docker-compose.yml

Utwórz plik o nazwie docker-compose.yml i dodaj następującą zawartość:

version: "3.9"
services:
  web:
    image: my-python-app
    ports:
      - "5000:5000"

Wyjaśnienie docker-compose.yml:* version: "3.9": Określa wersję pliku Docker Compose.

• services: Definiuje usługi aplikacji.
• web: Definiuje usługę o nazwie "web".
• image: my-python-app: Określa obraz używany przez usługę.
• ports: Definiuje mapowanie portów.

2. Uruchamianie aplikacji

W katalogu zawierającym plik docker-compose.yml uruchom następujące polecenie, aby uruchomić aplikację:

docker-compose up -d

• docker-compose up: Polecenie uruchamiające aplikację.
• -d: Uruchamia kontener w trybie odłączonym (w tle).

3. Zatrzymywanie aplikacji

Użyj następującego polecenia, aby zatrzymać aplikację:

docker-compose down

Najlepsze praktyki dotyczące bezpieczeństwa Dockera

Jak widać z dyskusji, bezpieczeństwo obrazów Dockera jest ważnym zagadnieniem. Poniżej przedstawiono kilka najlepszych praktyk dotyczących bezpieczeństwa Dockera:

• Używaj oficjalnych obrazów: W miarę możliwości używaj oficjalnie dostarczonych obrazów, które zazwyczaj są skanowane pod kątem bezpieczeństwa i utrzymywane.
• Skanuj obrazy pod kątem luk w zabezpieczeniach: Używaj narzędzi takich jak Trivy do skanowania obrazów pod kątem znanych luk w zabezpieczeniach i aktualizuj obrazy na bieżąco.
• Stosuj zasadę minimalnych uprawnień: Unikaj uruchamiania kontenerów jako użytkownik root.
• Ogranicz zasoby kontenera: Używaj cgroups do ograniczania zużycia procesora i pamięci przez kontener.
• Regularnie aktualizuj obrazy: Utrzymuj obrazy w aktualnym stanie, aby naprawiać luki w zabezpieczeniach.
• Używaj narzędzi do skanowania bezpieczeństwa: Narzędzia takie jak Snyk, Clair itp. można zintegrować z procesem CI/CD, aby automatycznie skanować obrazy pod kątem luk w zabezpieczeniach.

WniosekTen artykuł zawiera szybki przewodnik po Dockerze, obejmujący podstawowe koncepcje, kroki instalacji oraz prosty przykład konteneryzacji aplikacji Python. Ucząc się tych podstaw, możesz zacząć używać Dockera do budowania, testowania i wdrażania swoich aplikacji. Pamiętaj, że bezpieczeństwo jest najważniejsze, zawsze zwracaj uwagę na bezpieczeństwo obrazów Dockera i podejmuj odpowiednie kroki w celu ochrony swoich aplikacji. Chociaż Kubernetes jest potężny w zakresie orkiestracji kontenerów na dużą skalę, Docker w wielu scenariuszach pozostaje prostym i skutecznym rozwiązaniem. Opanowując Dockera, będziesz lepiej przygotowany do radzenia sobie z wyzwaniami współczesnego tworzenia i wdrażania oprogramowania.