← Back to blog

Konteneryzacja aplikacji Python za pomocą Docker

Preslav Dobrev2023-03-07 · 4 min read
Category
Konteneryzacja aplikacji Python za pomocą Docker

Docker to bezpłatne rozwiązanie open-source do tworzenia, wdrażania i zarządzania aplikacjami w lekkiej wirtualizacji na poziomie systemu operacyjnego. W tym przewodniku pokażemy, jak utworzyć aplikację Python w kontenerze Docker.

Wymagania wstępne

Aby wykonać kroki przedstawione w tym przewodniku, potrzebne będą następujące komponenty:

Kontenery Docker

Gdy uruchamiasz różne programy w tym samym środowisku, coś może się zepsuć — i prędzej czy później tak się stanie. Im więcej programów dodasz, tym bardziej niestabilne staje się środowisko. Dla przeciętnych użytkowników może nie być to duży problem. Jednak w przypadku aplikacji o znaczeniu krytycznym konsekwencje mogą być poważne.

Im więcej aplikacji znajduje się w systemie, tym większa jest powierzchnia ataku. Jedna przejęta aplikacja może łatwo doprowadzić do upadku całego systemu.

Aby rozwiązać te problemy, możemy użyć kontenerów Docker do izolacji na poziomie oprogramowania:

  • Aplikacje w kontenerze będą miały ograniczony dostęp do plików.

  • Aplikacje konteneryzowane nie widzą innych procesów działających w systemie.

  • Kontenerowi można przydzielić określoną ilość zasobów sprzętowych.

  • Porty sieciowe kontenera nie są wystawiane na zewnątrz.

  • Spójne pakowanie niemal wszystkiego w środowiskach lokalnych i produkcyjnych.

W ramach demonstracji zbudujemy prosty serwer Python w kontenerze Docker, przekształcimy kontener w obraz i wdrożymy obraz w przykładowym środowisku produkcyjnym.

Krok 1 – Konfiguracja systemu plików

Aby hostować projekt, najpierw utworzymy dedykowany katalog:

mkdir -pv python-server-container/
cd !$

W katalogu utwórz podkatalog src do przechowywania naszego kodu:

mkdir -pv src/

Krok 2 – Budowanie serwera Python

W tym kroku utworzymy prosty serwer HTTP w Pythonie. Utwórz plik server.py:

touch server.py

Otwórz go w edytorze tekstu:

nano server.py

Wprowadź następujący kod Python:

from http.server import HTTPServer, SimpleHTTPRequestHandler

def run(server_class=HTTPServer, handler_class=SimpleHTTPRequestHandler):
    """server entrypoint"""
    server_address = ("0.0.0.0", 8080)
    httpd = server_class(server_address, handler_class)
    print("starting server...")
    httpd.serve_forever()

if __name__ == "__main__":
    run()

Tutaj:

  • Używamy klasy HTTPServer i handlera ze standardowej biblioteki Python, dzięki czemu program pozostaje prosty.

  • Funkcja run inicjuje instancję HTTPserver.

  • Jak sugerują argumenty server_address, serwer będzie nasłuchiwał wszystkich połączeń przychodzących na porcie 8080.

Teraz sprawdzimy, czy serwer działa zgodnie z oczekiwaniami. Uruchom serwer:

python3 server.py

Z nowego terminala możemy użyć curl, aby wysłać żądanie do serwera:

curl -iv localhost:8080

Alternatywnie możesz otworzyć link w przeglądarce internetowej:

http://localhost:8080

Krok 3 – Tworzenie Dockerfile

Dockerfile zawiera instrukcje niezbędne do wygenerowania obrazu Docker. Instrukcje w pliku są wykonywane sekwencyjnie. Dowiedz się więcej o Dockerfile.

Utwórz nowy Dockerfile dla naszego projektu:

touch Dockerfile

Teraz dodamy do niego niezbędny kod. Otwórz go w edytorze tekstu:

nano Dockerfile

Wprowadź następujący kod:

FROM python:latest

ENV SRC_DIR /usr/bin/src/test_server/src
COPY src/* ${SRC_DIR}/
WORKDIR ${SRC_DIR}

ENV PYTHONUNBUFFERED=1

CMD ["python", "server.py"]

Tutaj:

  • Każdy Dockerfile musi zaczynać się od dyrektywy FROM. W naszym przypadku deklarujemy Python jako bazę obrazu Docker.

  • Dyrektywa ENV SRC_DIR określa lokalizację katalogu kontenera.

  • Dyrektywa COPY kopiuje pliki z katalogu src, w którym obecnie znajduje się serwer Python.

  • Zmienna PYTHONBUFFERED=1 określa, że Python będzie wypisywał i logował dane wyjściowe bezpośrednio do STDOUT. W przeciwnym razie logi nie byłyby wysyłane do żadnego bufora.

  • Dyrektywa CMD określa domyślne polecenie uruchamiane podczas wykonywania kontenera. W tym przypadku używamy jej do uruchomienia naszego serwera Python.

Krok 4 – Generowanie obrazu Docker

Gdy Dockerfile jest gotowy, możemy utworzyć obraz. Uruchom następujące polecenie Docker, aby rozpocząć proces:

docker build . -t python_server

Tutaj:

  • Flaga -t służy do oznaczenia naszego obrazu Docker jako python_server.

  • Docker pobierze wszystkie niezbędne komponenty i połączy je w obraz.

Krok 5 – Uruchamianie obrazu

Obraz jest gotowy do wdrożenia. Możemy go uruchomić za pomocą następującego polecenia:

docker run -p 8080:8080 python_server

Tutaj przekierowujemy port 8080 z lokalnej maszyny do obrazu Docker, używając flagi -p.

Możemy łatwo sprawdzić, czy serwer działa, używając curl:

curl -iv localhost:8080

Krok 6 – Zatrzymywanie serwera

W terminalu naciśnij “Ctrl + C”, aby zakończyć proces Docker:

Krok 7 – Eksportowanie i importowanie obrazu Docker

Mamy teraz działający obraz Docker hostujący nasz serwer Python. Dzięki funkcjom eksportu i importu Docker możemy przenieść go do dowolnego innego systemu.

Najpierw sprawdź listę obrazów Docker w bieżącym systemie:

docker images

Naszym celem jest obraz Docker python_server, który właśnie utworzyliśmy. Następujące polecenie wyeksportuje go jako archiwum TAR:

docker save python_server:latest > python_server.tar

Po przeniesieniu pliku python_server.tar na maszynę docelową użyj następującego polecenia, aby zaimportować obraz Docker:

docker load < python_server.tar

Podsumowanie

W tym przewodniku pokazaliśmy, jak zbudować obraz Docker z aplikacji Python. Utworzyliśmy prosty serwer WWW w Pythonie i zbudowaliśmy z niego obraz Docker. Obraz Docker można teraz wdrożyć w dowolnym środowisku i oczekiwać spójnego działania.

Chcesz dowiedzieć się więcej o Docker? Sprawdź następujące przewodniki:

Miłej pracy z komputerem!

Preslav Dobrev

Autor · CloudSigma

Komentarze

Brak komentarzy. Bądź pierwszy.